Adding upstream version 115.8.0esr.upstream/115.8.0esr

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1654 insertions, 0 deletions

diff --git a/dom/media/webrtc/jsapi/RTCRtpSender.cpp b/dom/media/webrtc/jsapi/RTCRtpSender.cpp
new file mode 100644
index 0000000000..568a83e8d1
--- /dev/null
+++ b/dom/media/webrtc/jsapi/RTCRtpSender.cpp
@@ -0,0 +1,1654 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "RTCRtpSender.h"
+#include "transport/logging.h"
+#include "mozilla/dom/MediaStreamTrack.h"
+#include "mozilla/dom/Promise.h"
+#include "mozilla/glean/GleanMetrics.h"
+#include "nsPIDOMWindow.h"
+#include "nsString.h"
+#include "mozilla/dom/VideoStreamTrack.h"
+#include "jsep/JsepTransceiver.h"
+#include "mozilla/dom/RTCRtpSenderBinding.h"
+#include "RTCStatsReport.h"
+#include "mozilla/Preferences.h"
+#include "RTCRtpTransceiver.h"
+#include "PeerConnectionImpl.h"
+#include "libwebrtcglue/AudioConduit.h"
+#include <vector>
+#include "call/call.h"
+
+namespace mozilla::dom {
+
+LazyLogModule gSenderLog("RTCRtpSender");
+
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(RTCRtpSender)
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(RTCRtpSender)
+  // We do not do anything here, we wait for BreakCycles to be called
+  NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(RTCRtpSender)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mWindow, mPc, mSenderTrack, mTransceiver,
+                                    mStreams, mDtmf)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(RTCRtpSender)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(RTCRtpSender)
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(RTCRtpSender)
+  NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+  NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+
+#define INIT_CANONICAL(name, val) \
+  name(AbstractThread::MainThread(), val, "RTCRtpSender::" #name " (Canonical)")
+
+RTCRtpSender::RTCRtpSender(nsPIDOMWindowInner* aWindow, PeerConnectionImpl* aPc,
+                           MediaTransportHandler* aTransportHandler,
+                           AbstractThread* aCallThread,
+                           nsISerialEventTarget* aStsThread,
+                           MediaSessionConduit* aConduit,
+                           dom::MediaStreamTrack* aTrack,
+                           const Sequence<RTCRtpEncodingParameters>& aEncodings,
+                           RTCRtpTransceiver* aTransceiver)
+    : mWatchManager(this, AbstractThread::MainThread()),
+      mWindow(aWindow),
+      mPc(aPc),
+      mSenderTrack(aTrack),
+      mTransportHandler(aTransportHandler),
+      mTransceiver(aTransceiver),
+      INIT_CANONICAL(mSsrcs, Ssrcs()),
+      INIT_CANONICAL(mVideoRtxSsrcs, Ssrcs()),
+      INIT_CANONICAL(mLocalRtpExtensions, RtpExtList()),
+      INIT_CANONICAL(mAudioCodec, Nothing()),
+      INIT_CANONICAL(mVideoCodec, Nothing()),
+      INIT_CANONICAL(mVideoRtpRtcpConfig, Nothing()),
+      INIT_CANONICAL(mVideoCodecMode, webrtc::VideoCodecMode::kRealtimeVideo),
+      INIT_CANONICAL(mCname, std::string()),
+      INIT_CANONICAL(mTransmitting, false) {
+  mPipeline = new MediaPipelineTransmit(
+      mPc->GetHandle(), aTransportHandler, aCallThread, aStsThread,
+      aConduit->type() == MediaSessionConduit::VIDEO, aConduit);
+  mPipeline->InitControl(this);
+
+  if (aConduit->type() == MediaSessionConduit::AUDIO) {
+    mDtmf = new RTCDTMFSender(aWindow, mTransceiver);
+  }
+  mPipeline->SetTrack(mSenderTrack);
+
+  mozilla::glean::rtcrtpsender::count.Add(1);
+
+  if (mPc->ShouldAllowOldSetParameters()) {
+    mAllowOldSetParameters = true;
+    mozilla::glean::rtcrtpsender::count_setparameters_compat.Add(1);
+  }
+
+  if (aEncodings.Length()) {
+    // This sender was created by addTransceiver with sendEncodings.
+    mParameters.mEncodings = aEncodings;
+    mSimulcastEnvelopeSet = true;
+    mozilla::glean::rtcrtpsender::used_sendencodings.AddToNumerator(1);
+  } else {
+    // This sender was created by addTrack, sRD(offer), or addTransceiver
+    // without sendEncodings.
+    RTCRtpEncodingParameters defaultEncoding;
+    defaultEncoding.mActive = true;
+    if (aConduit->type() == MediaSessionConduit::VIDEO) {
+      defaultEncoding.mScaleResolutionDownBy.Construct(1.0f);
+    }
+    Unused << mParameters.mEncodings.AppendElement(defaultEncoding, fallible);
+    UpdateRestorableEncodings(mParameters.mEncodings);
+    MaybeGetJsepRids();
+  }
+
+  if (mDtmf) {
+    mWatchManager.Watch(mTransmitting, &RTCRtpSender::UpdateDtmfSender);
+  }
+}
+
+#undef INIT_CANONICAL
+
+RTCRtpSender::~RTCRtpSender() = default;
+
+JSObject* RTCRtpSender::WrapObject(JSContext* aCx,
+                                   JS::Handle<JSObject*> aGivenProto) {
+  return RTCRtpSender_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+RTCDtlsTransport* RTCRtpSender::GetTransport() const {
+  if (!mTransceiver) {
+    return nullptr;
+  }
+  return mTransceiver->GetDtlsTransport();
+}
+
+RTCDTMFSender* RTCRtpSender::GetDtmf() const { return mDtmf; }
+
+already_AddRefed<Promise> RTCRtpSender::GetStats(ErrorResult& aError) {
+  RefPtr<Promise> promise = MakePromise(aError);
+  if (aError.Failed()) {
+    return nullptr;
+  }
+  if (NS_WARN_IF(!mPipeline)) {
+    // TODO(bug 1056433): When we stop nulling this out when the PC is closed
+    // (or when the transceiver is stopped), we can remove this code. We
+    // resolve instead of reject in order to make this eventual change in
+    // behavior a little smaller.
+    promise->MaybeResolve(new RTCStatsReport(mWindow));
+    return promise.forget();
+  }
+
+  if (!mSenderTrack) {
+    promise->MaybeResolve(new RTCStatsReport(mWindow));
+    return promise.forget();
+  }
+
+  mTransceiver->ChainToDomPromiseWithCodecStats(GetStatsInternal(), promise);
+  return promise.forget();
+}
+
+nsTArray<RefPtr<dom::RTCStatsPromise>> RTCRtpSender::GetStatsInternal(
+    bool aSkipIceStats) {
+  MOZ_ASSERT(NS_IsMainThread());
+  nsTArray<RefPtr<RTCStatsPromise>> promises(2);
+  if (!mSenderTrack || !mPipeline) {
+    return promises;
+  }
+
+  nsAutoString trackName;
+  if (auto track = mPipeline->GetTrack()) {
+    track->GetId(trackName);
+  }
+
+  {
+    // Add bandwidth estimation stats
+    promises.AppendElement(InvokeAsync(
+        mPipeline->mCallThread, __func__,
+        [conduit = mPipeline->mConduit, trackName]() mutable {
+          auto report = MakeUnique<dom::RTCStatsCollection>();
+          Maybe<webrtc::Call::Stats> stats = conduit->GetCallStats();
+          stats.apply([&](const auto aStats) {
+            dom::RTCBandwidthEstimationInternal bw;
+            bw.mTrackIdentifier = trackName;
+            bw.mSendBandwidthBps.Construct(aStats.send_bandwidth_bps / 8);
+            bw.mMaxPaddingBps.Construct(aStats.max_padding_bitrate_bps / 8);
+            bw.mReceiveBandwidthBps.Construct(aStats.recv_bandwidth_bps / 8);
+            bw.mPacerDelayMs.Construct(aStats.pacer_delay_ms);
+            if (aStats.rtt_ms >= 0) {
+              bw.mRttMs.Construct(aStats.rtt_ms);
+            }
+            if (!report->mBandwidthEstimations.AppendElement(std::move(bw),
+                                                             fallible)) {
+              mozalloc_handle_oom(0);
+            }
+          });
+          return RTCStatsPromise::CreateAndResolve(std::move(report), __func__);
+        }));
+  }
+
+  promises.AppendElement(InvokeAsync(
+      mPipeline->mCallThread, __func__, [pipeline = mPipeline, trackName] {
+        auto report = MakeUnique<dom::RTCStatsCollection>();
+        auto asAudio = pipeline->mConduit->AsAudioSessionConduit();
+        auto asVideo = pipeline->mConduit->AsVideoSessionConduit();
+
+        nsString kind = asVideo.isNothing() ? u"audio"_ns : u"video"_ns;
+        nsString idstr = kind + u"_"_ns;
+        idstr.AppendInt(static_cast<uint32_t>(pipeline->Level()));
+
+        for (uint32_t ssrc : pipeline->mConduit->GetLocalSSRCs()) {
+          nsString localId = u"outbound_rtp_"_ns + idstr + u"_"_ns;
+          localId.AppendInt(ssrc);
+          nsString remoteId;
+          Maybe<uint16_t> base_seq =
+              pipeline->mConduit->RtpSendBaseSeqFor(ssrc);
+
+          auto constructCommonRemoteInboundRtpStats =
+              [&](RTCRemoteInboundRtpStreamStats& aRemote,
+                  const webrtc::ReportBlockData& aRtcpData) {
+                remoteId = u"outbound_rtcp_"_ns + idstr + u"_"_ns;
+                remoteId.AppendInt(ssrc);
+                aRemote.mTimestamp.Construct(
+                    RTCStatsTimestamp::FromNtp(
+                        pipeline->GetTimestampMaker(),
+                        webrtc::Timestamp::Micros(
+                            aRtcpData.report_block_timestamp_utc_us()) +
+                            webrtc::TimeDelta::Seconds(webrtc::kNtpJan1970))
+                        .ToDom());
+                aRemote.mId.Construct(remoteId);
+                aRemote.mType.Construct(RTCStatsType::Remote_inbound_rtp);
+                aRemote.mSsrc = ssrc;
+                aRemote.mKind = kind;
+                aRemote.mMediaType.Construct(
+                    kind);  // mediaType is the old name for kind.
+                aRemote.mLocalId.Construct(localId);
+                if (base_seq) {
+                  if (aRtcpData.report_block()
+                          .extended_highest_sequence_number < *base_seq) {
+                    aRemote.mPacketsReceived.Construct(0);
+                  } else {
+                    aRemote.mPacketsReceived.Construct(
+                        aRtcpData.report_block()
+                            .extended_highest_sequence_number -
+                        aRtcpData.report_block().packets_lost - *base_seq + 1);
+                  }
+                }
+              };
+
+          auto constructCommonOutboundRtpStats =
+              [&](RTCOutboundRtpStreamStats& aLocal) {
+                aLocal.mSsrc = ssrc;
+                aLocal.mTimestamp.Construct(
+                    pipeline->GetTimestampMaker().GetNow().ToDom());
+                aLocal.mId.Construct(localId);
+                aLocal.mType.Construct(RTCStatsType::Outbound_rtp);
+                aLocal.mKind = kind;
+                aLocal.mMediaType.Construct(
+                    kind);  // mediaType is the old name for kind.
+                if (remoteId.Length()) {
+                  aLocal.mRemoteId.Construct(remoteId);
+                }
+              };
+
+          asAudio.apply([&](auto& aConduit) {
+            Maybe<webrtc::AudioSendStream::Stats> audioStats =
+                aConduit->GetSenderStats();
+            if (audioStats.isNothing()) {
+              return;
+            }
+
+            if (audioStats->packets_sent == 0) {
+              // By spec: "The lifetime of all RTP monitored objects starts
+              // when the RTP stream is first used: When the first RTP packet
+              // is sent or received on the SSRC it represents"
+              return;
+            }
+
+            // First, fill in remote stat with rtcp receiver data, if present.
+            // ReceiverReports have less information than SenderReports, so fill
+            // in what we can.
+            Maybe<webrtc::ReportBlockData> reportBlockData;
+            {
+              if (const auto remoteSsrc = aConduit->GetRemoteSSRC();
+                  remoteSsrc) {
+                for (auto& data : audioStats->report_block_datas) {
+                  if (data.report_block().source_ssrc == ssrc &&
+                      data.report_block().sender_ssrc == *remoteSsrc) {
+                    reportBlockData.emplace(data);
+                    break;
+                  }
+                }
+              }
+            }
+            reportBlockData.apply([&](auto& aReportBlockData) {
+              RTCRemoteInboundRtpStreamStats remote;
+              constructCommonRemoteInboundRtpStats(remote, aReportBlockData);
+              if (audioStats->jitter_ms >= 0) {
+                remote.mJitter.Construct(audioStats->jitter_ms / 1000.0);
+              }
+              if (audioStats->packets_lost >= 0) {
+                remote.mPacketsLost.Construct(audioStats->packets_lost);
+              }
+              if (audioStats->rtt_ms >= 0) {
+                remote.mRoundTripTime.Construct(
+                    static_cast<double>(audioStats->rtt_ms) / 1000.0);
+              }
+              remote.mFractionLost.Construct(audioStats->fraction_lost);
+              remote.mTotalRoundTripTime.Construct(
+                  double(aReportBlockData.sum_rtt_ms()) / 1000);
+              remote.mRoundTripTimeMeasurements.Construct(
+                  aReportBlockData.num_rtts());
+              if (!report->mRemoteInboundRtpStreamStats.AppendElement(
+                      std::move(remote), fallible)) {
+                mozalloc_handle_oom(0);
+              }
+            });
+
+            // Then, fill in local side (with cross-link to remote only if
+            // present)
+            RTCOutboundRtpStreamStats local;
+            constructCommonOutboundRtpStats(local);
+            local.mPacketsSent.Construct(audioStats->packets_sent);
+            local.mBytesSent.Construct(audioStats->payload_bytes_sent);
+            local.mNackCount.Construct(
+                audioStats->rtcp_packet_type_counts.nack_packets);
+            local.mHeaderBytesSent.Construct(
+                audioStats->header_and_padding_bytes_sent);
+            local.mRetransmittedPacketsSent.Construct(
+                audioStats->retransmitted_packets_sent);
+            local.mRetransmittedBytesSent.Construct(
+                audioStats->retransmitted_bytes_sent);
+            /*
+             * Potential new stats that are now available upstream.
+             * Note: when we last tried exposing this we were getting
+             * targetBitrate for audio was ending up as 0. We did not
+             * investigate why.
+            local.mTargetBitrate.Construct(audioStats->target_bitrate_bps);
+             */
+            if (!report->mOutboundRtpStreamStats.AppendElement(std::move(local),
+                                                               fallible)) {
+              mozalloc_handle_oom(0);
+            }
+          });
+
+          asVideo.apply([&](auto& aConduit) {
+            Maybe<webrtc::VideoSendStream::Stats> videoStats =
+                aConduit->GetSenderStats();
+            if (videoStats.isNothing()) {
+              return;
+            }
+
+            Maybe<webrtc::VideoSendStream::StreamStats> streamStats;
+            auto kv = videoStats->substreams.find(ssrc);
+            if (kv != videoStats->substreams.end()) {
+              streamStats = Some(kv->second);
+            }
+
+            if (!streamStats) {
+              // By spec: "The lifetime of all RTP monitored objects starts
+              // when the RTP stream is first used: When the first RTP packet
+              // is sent or received on the SSRC it represents"
+              return;
+            }
+
+            aConduit->GetAssociatedLocalRtxSSRC(ssrc).apply(
+                [&](const auto rtxSsrc) {
+                  auto kv = videoStats->substreams.find(rtxSsrc);
+                  if (kv != videoStats->substreams.end()) {
+                    streamStats->rtp_stats.Add(kv->second.rtp_stats);
+                  }
+                });
+
+            if (streamStats->rtp_stats.first_packet_time_ms == -1) {
+              return;
+            }
+
+            // First, fill in remote stat with rtcp receiver data, if present.
+            // ReceiverReports have less information than SenderReports, so fill
+            // in what we can.
+            if (streamStats->report_block_data) {
+              const webrtc::ReportBlockData& rtcpReportData =
+                  *streamStats->report_block_data;
+              RTCRemoteInboundRtpStreamStats remote;
+              remote.mJitter.Construct(
+                  static_cast<double>(rtcpReportData.report_block().jitter) /
+                  webrtc::kVideoPayloadTypeFrequency);
+              remote.mPacketsLost.Construct(
+                  rtcpReportData.report_block().packets_lost);
+              if (rtcpReportData.has_rtt()) {
+                remote.mRoundTripTime.Construct(
+                    static_cast<double>(rtcpReportData.last_rtt_ms()) / 1000.0);
+              }
+              constructCommonRemoteInboundRtpStats(remote, rtcpReportData);
+              remote.mTotalRoundTripTime.Construct(
+                  streamStats->report_block_data->sum_rtt_ms() / 1000.0);
+              remote.mFractionLost.Construct(
+                  static_cast<float>(
+                      rtcpReportData.report_block().fraction_lost) /
+                  (1 << 8));
+              remote.mRoundTripTimeMeasurements.Construct(
+                  streamStats->report_block_data->num_rtts());
+              if (!report->mRemoteInboundRtpStreamStats.AppendElement(
+                      std::move(remote), fallible)) {
+                mozalloc_handle_oom(0);
+              }
+            }
+
+            // Then, fill in local side (with cross-link to remote only if
+            // present)
+            RTCOutboundRtpStreamStats local;
+            constructCommonOutboundRtpStats(local);
+            local.mPacketsSent.Construct(
+                streamStats->rtp_stats.transmitted.packets);
+            local.mBytesSent.Construct(
+                streamStats->rtp_stats.transmitted.payload_bytes);
+            local.mNackCount.Construct(
+                streamStats->rtcp_packet_type_counts.nack_packets);
+            local.mFirCount.Construct(
+                streamStats->rtcp_packet_type_counts.fir_packets);
+            local.mPliCount.Construct(
+                streamStats->rtcp_packet_type_counts.pli_packets);
+            local.mFramesEncoded.Construct(streamStats->frames_encoded);
+            if (streamStats->qp_sum) {
+              local.mQpSum.Construct(*streamStats->qp_sum);
+            }
+            local.mHeaderBytesSent.Construct(
+                streamStats->rtp_stats.transmitted.header_bytes +
+                streamStats->rtp_stats.transmitted.padding_bytes);
+            local.mRetransmittedPacketsSent.Construct(
+                streamStats->rtp_stats.retransmitted.packets);
+            local.mRetransmittedBytesSent.Construct(
+                streamStats->rtp_stats.retransmitted.payload_bytes);
+            local.mTotalEncodedBytesTarget.Construct(
+                videoStats->total_encoded_bytes_target);
+            local.mFrameWidth.Construct(streamStats->width);
+            local.mFrameHeight.Construct(streamStats->height);
+            local.mFramesSent.Construct(streamStats->frames_encoded);
+            local.mHugeFramesSent.Construct(streamStats->huge_frames_sent);
+            local.mTotalEncodeTime.Construct(
+                double(streamStats->total_encode_time_ms) / 1000.);
+            /*
+             * Potential new stats that are now available upstream.
+            local.mTargetBitrate.Construct(videoStats->target_media_bitrate_bps);
+             */
+            if (!report->mOutboundRtpStreamStats.AppendElement(std::move(local),
+                                                               fallible)) {
+              mozalloc_handle_oom(0);
+            }
+          });
+        }
+
+        auto constructCommonMediaSourceStats =
+            [&](RTCMediaSourceStats& aStats) {
+              nsString id = u"mediasource_"_ns + idstr + trackName;
+              aStats.mTimestamp.Construct(
+                  pipeline->GetTimestampMaker().GetNow().ToDom());
+              aStats.mId.Construct(id);
+              aStats.mType.Construct(RTCStatsType::Media_source);
+              aStats.mTrackIdentifier = trackName;
+              aStats.mKind = kind;
+            };
+
+        // TODO(bug 1804678): Use RTCAudioSourceStats/RTCVideoSourceStats
+        RTCMediaSourceStats mediaSourceStats;
+        constructCommonMediaSourceStats(mediaSourceStats);
+        if (!report->mMediaSourceStats.AppendElement(
+                std::move(mediaSourceStats), fallible)) {
+          mozalloc_handle_oom(0);
+        }
+
+        return RTCStatsPromise::CreateAndResolve(std::move(report), __func__);
+      }));
+
+  if (!aSkipIceStats && GetJsepTransceiver().mTransport.mComponents) {
+    promises.AppendElement(mTransportHandler->GetIceStats(
+        GetJsepTransceiver().mTransport.mTransportId,
+        mPipeline->GetTimestampMaker().GetNow().ToDom()));
+  }
+
+  return promises;
+}
+
+void RTCRtpSender::GetCapabilities(const GlobalObject&, const nsAString& aKind,
+                                   Nullable<dom::RTCRtpCapabilities>& aResult) {
+  PeerConnectionImpl::GetCapabilities(aKind, aResult, sdp::Direction::kSend);
+}
+
+void RTCRtpSender::WarnAboutBadSetParameters(const nsCString& aError) {
+  nsCString warning(
+      "WARNING! Invalid setParameters call detected! The good news? Firefox "
+      "supports sendEncodings in addTransceiver now, so we ask that you switch "
+      "over to using the parameters code you use for other browsers. Thank you "
+      "for your patience and support. The specific error was: ");
+  warning += aError;
+  mPc->SendWarningToConsole(warning);
+}
+
+nsCString RTCRtpSender::GetEffectiveTLDPlus1() const {
+  return mPc->GetEffectiveTLDPlus1();
+}
+
+already_AddRefed<Promise> RTCRtpSender::SetParameters(
+    const dom::RTCRtpSendParameters& aParameters, ErrorResult& aError) {
+  dom::RTCRtpSendParameters paramsCopy(aParameters);
+  // When the setParameters method is called, the user agent MUST run the
+  // following steps:
+  // Let parameters be the method's first argument.
+  // Let sender be the RTCRtpSender object on which setParameters is invoked.
+  // Let transceiver be the RTCRtpTransceiver object associated with sender
+  // (i.e.sender is transceiver.[[Sender]]).
+
+  RefPtr<dom::Promise> p = MakePromise(aError);
+  if (aError.Failed()) {
+    return nullptr;
+  }
+
+  if (mPc->IsClosed()) {
+    p->MaybeRejectWithInvalidStateError("Peer connection is closed");
+    return p.forget();
+  }
+
+  // If transceiver.[[Stopped]] is true, return a promise rejected with a newly
+  // created InvalidStateError.
+  if (mTransceiver->Stopped()) {
+    p->MaybeRejectWithInvalidStateError("This sender's transceiver is stopped");
+    return p.forget();
+  }
+
+  // If sender.[[LastReturnedParameters]] is null, return a promise rejected
+  // with a newly created InvalidStateError.
+  if (!mLastReturnedParameters.isSome()) {
+    nsCString error(
+        "Cannot call setParameters without first calling getParameters");
+    if (mAllowOldSetParameters) {
+      if (!mHaveWarnedBecauseNoGetParameters) {
+        mHaveWarnedBecauseNoGetParameters = true;
+        mozilla::glean::rtcrtpsender_setparameters::warn_no_getparameters
+            .AddToNumerator(1);
+#ifdef EARLY_BETA_OR_EARLIER
+        mozilla::glean::rtcrtpsender_setparameters::blame_no_getparameters
+            .Get(GetEffectiveTLDPlus1())
+            .Add(1);
+#endif
+      }
+      WarnAboutBadSetParameters(error);
+    } else {
+      if (!mHaveFailedBecauseNoGetParameters) {
+        mHaveFailedBecauseNoGetParameters = true;
+        mozilla::glean::rtcrtpsender_setparameters::fail_no_getparameters
+            .AddToNumerator(1);
+      }
+      p->MaybeRejectWithInvalidStateError(error);
+      return p.forget();
+    }
+  }
+
+  // According to the spec, our consistency checking is based on
+  // [[LastReturnedParameters]], but if we're letting
+  // [[LastReturnedParameters]]==null slide, we still want to do
+  // consistency checking on _something_ so we can warn implementers if they
+  // are messing that up also. Just find something, _anything_, to do that
+  // checking with.
+  // TODO(bug 1803388): Remove this stuff once it is no longer needed.
+  // TODO(bug 1803389): Remove the glean errors once they are no longer needed.
+  Maybe<RTCRtpSendParameters> oldParams;
+  if (mAllowOldSetParameters) {
+    if (mLastReturnedParameters.isSome()) {
+      oldParams = mLastReturnedParameters;
+    } else if (mPendingParameters.isSome()) {
+      oldParams = mPendingParameters;
+    } else {
+      oldParams = Some(mParameters);
+    }
+    MOZ_ASSERT(oldParams.isSome());
+  } else {
+    oldParams = mLastReturnedParameters;
+  }
+  MOZ_ASSERT(oldParams.isSome());
+
+  // Validate parameters by running the following steps:
+  // Let encodings be parameters.encodings.
+  // Let codecs be parameters.codecs.
+  // Let N be the number of RTCRtpEncodingParameters stored in
+  // sender.[[SendEncodings]].
+  // If any of the following conditions are met,
+  // return a promise rejected with a newly created InvalidModificationError:
+
+  bool pendingRidChangeFromCompatMode = false;
+  // encodings.length is different from N.
+  if (paramsCopy.mEncodings.Length() != oldParams->mEncodings.Length()) {
+    nsCString error("Cannot change the number of encodings with setParameters");
+    if (!mAllowOldSetParameters) {
+      if (!mHaveFailedBecauseEncodingCountChange) {
+        mHaveFailedBecauseEncodingCountChange = true;
+        mozilla::glean::rtcrtpsender_setparameters::fail_length_changed
+            .AddToNumerator(1);
+      }
+      p->MaybeRejectWithInvalidModificationError(error);
+      return p.forget();
+    }
+    // Make sure we don't use the old rids in SyncToJsep while we wait for the
+    // queued task below to update mParameters.
+    pendingRidChangeFromCompatMode = true;
+    mSimulcastEnvelopeSet = true;
+    if (!mHaveWarnedBecauseEncodingCountChange) {
+      mHaveWarnedBecauseEncodingCountChange = true;
+      mozilla::glean::rtcrtpsender_setparameters::warn_length_changed
+          .AddToNumerator(1);
+#ifdef EARLY_BETA_OR_EARLIER
+      mozilla::glean::rtcrtpsender_setparameters::blame_length_changed
+          .Get(GetEffectiveTLDPlus1())
+          .Add(1);
+#endif
+    }
+    WarnAboutBadSetParameters(error);
+  } else {
+    // encodings has been re-ordered.
+    for (size_t i = 0; i < paramsCopy.mEncodings.Length(); ++i) {
+      const auto& oldEncoding = oldParams->mEncodings[i];
+      const auto& newEncoding = paramsCopy.mEncodings[i];
+      if (oldEncoding.mRid != newEncoding.mRid) {
+        nsCString error("Cannot change rid, or reorder encodings");
+        if (!mHaveFailedBecauseRidChange) {
+          mHaveFailedBecauseRidChange = true;
+          mozilla::glean::rtcrtpsender_setparameters::fail_rid_changed
+              .AddToNumerator(1);
+        }
+        p->MaybeRejectWithInvalidModificationError(error);
+        return p.forget();
+      }
+    }
+  }
+
+  // TODO(bug 1803388): Handle this in webidl, once we stop allowing the old
+  // setParameters style.
+  if (!paramsCopy.mTransactionId.WasPassed()) {
+    nsCString error("transactionId is not set!");
+    if (!mAllowOldSetParameters) {
+      if (!mHaveFailedBecauseNoTransactionId) {
+        mHaveFailedBecauseNoTransactionId = true;
+        mozilla::glean::rtcrtpsender_setparameters::fail_no_transactionid
+            .AddToNumerator(1);
+      }
+      p->MaybeRejectWithTypeError(error);
+      return p.forget();
+    }
+    if (!mHaveWarnedBecauseNoTransactionId) {
+      mHaveWarnedBecauseNoTransactionId = true;
+      mozilla::glean::rtcrtpsender_setparameters::warn_no_transactionid
+          .AddToNumerator(1);
+#ifdef EARLY_BETA_OR_EARLIER
+      mozilla::glean::rtcrtpsender_setparameters::blame_no_transactionid
+          .Get(GetEffectiveTLDPlus1())
+          .Add(1);
+#endif
+    }
+    WarnAboutBadSetParameters(error);
+  } else if (oldParams->mTransactionId != paramsCopy.mTransactionId) {
+    // Any parameter in parameters is marked as a Read-only parameter (such as
+    // RID) and has a value that is different from the corresponding parameter
+    // value in sender.[[LastReturnedParameters]]. Note that this also applies
+    // to transactionId.
+    nsCString error(
+        "Cannot change transaction id: call getParameters, modify the result, "
+        "and then call setParameters");
+    if (!mAllowOldSetParameters) {
+      if (!mHaveFailedBecauseStaleTransactionId) {
+        mHaveFailedBecauseStaleTransactionId = true;
+        mozilla::glean::rtcrtpsender_setparameters::fail_stale_transactionid
+            .AddToNumerator(1);
+      }
+      p->MaybeRejectWithInvalidModificationError(error);
+      return p.forget();
+    }
+    if (!mHaveWarnedBecauseStaleTransactionId) {
+      mHaveWarnedBecauseStaleTransactionId = true;
+      mozilla::glean::rtcrtpsender_setparameters::warn_stale_transactionid
+          .AddToNumerator(1);
+#ifdef EARLY_BETA_OR_EARLIER
+      mozilla::glean::rtcrtpsender_setparameters::blame_stale_transactionid
+          .Get(GetEffectiveTLDPlus1())
+          .Add(1);
+#endif
+    }
+    WarnAboutBadSetParameters(error);
+  }
+
+  // This could conceivably happen if we are allowing the old setParameters
+  // behavior.
+  if (!paramsCopy.mEncodings.Length()) {
+    nsCString error("Cannot set an empty encodings array");
+    if (!mAllowOldSetParameters) {
+      if (!mHaveFailedBecauseNoEncodings) {
+        mHaveFailedBecauseNoEncodings = true;
+        mozilla::glean::rtcrtpsender_setparameters::fail_no_encodings
+            .AddToNumerator(1);
+      }
+
+      p->MaybeRejectWithInvalidModificationError(error);
+      return p.forget();
+    }
+    // TODO: Add some warning telemetry here
+    WarnAboutBadSetParameters(error);
+    // Just don't do this; it's stupid.
+    paramsCopy.mEncodings = oldParams->mEncodings;
+  }
+
+  // TODO: Verify remaining read-only parameters
+  // headerExtensions (bug 1765851)
+  // rtcp (bug 1765852)
+  // codecs (bug 1534687)
+
+  // CheckAndRectifyEncodings handles the following steps:
+  // If transceiver kind is "audio", remove the scaleResolutionDownBy member
+  // from all encodings that contain one.
+  //
+  // If transceiver kind is "video", and any encoding in encodings contains a
+  // scaleResolutionDownBy member whose value is less than 1.0, return a
+  // promise rejected with a newly created RangeError.
+  //
+  // Verify that each encoding in encodings has a maxFramerate member whose
+  // value is greater than or equal to 0.0. If one of the maxFramerate values
+  // does not meet this requirement, return a promise rejected with a newly
+  // created RangeError.
+  ErrorResult rv;
+  CheckAndRectifyEncodings(paramsCopy.mEncodings, mTransceiver->IsVideo(), rv);
+  if (rv.Failed()) {
+    if (!mHaveFailedBecauseOtherError) {
+      mHaveFailedBecauseOtherError = true;
+      mozilla::glean::rtcrtpsender_setparameters::fail_other.AddToNumerator(1);
+    }
+    p->MaybeReject(std::move(rv));
+    return p.forget();
+  }
+
+  // If transceiver kind is "video", then for each encoding in encodings that
+  // doesn't contain a scaleResolutionDownBy member, add a
+  // scaleResolutionDownBy member with the value 1.0.
+  if (mTransceiver->IsVideo()) {
+    for (auto& encoding : paramsCopy.mEncodings) {
+      if (!encoding.mScaleResolutionDownBy.WasPassed()) {
+        encoding.mScaleResolutionDownBy.Construct(1.0);
+      }
+    }
+  }
+
+  // Let p be a new promise. (see above)
+
+  // In parallel, configure the media stack to use parameters to transmit
+  // sender.[[SenderTrack]].
+  // Right now this is infallible. That may change someday.
+
+  // We need to put this in a member variable, since MaybeUpdateConduit needs it
+  // This also allows PeerConnectionImpl to detect when there is a pending
+  // setParameters, which has implcations for the handling of
+  // setRemoteDescription.
+  mPendingRidChangeFromCompatMode = pendingRidChangeFromCompatMode;
+  mPendingParameters = Some(paramsCopy);
+  uint32_t serialNumber = ++mNumSetParametersCalls;
+  MaybeUpdateConduit();
+
+  // If the media stack is successfully configured with parameters,
+  // queue a task to run the following steps:
+  GetMainThreadSerialEventTarget()->Dispatch(NS_NewRunnableFunction(
+      __func__,
+      [this, self = RefPtr<RTCRtpSender>(this), p, paramsCopy, serialNumber] {
+        // Set sender.[[LastReturnedParameters]] to null.
+        mLastReturnedParameters = Nothing();
+        // Set sender.[[SendEncodings]] to parameters.encodings.
+        mParameters = paramsCopy;
+        UpdateRestorableEncodings(mParameters.mEncodings);
+        // Only clear mPendingParameters if it matches; there could have been
+        // back-to-back calls to setParameters, and we only want to clear this
+        // if no subsequent setParameters is pending.
+        if (serialNumber == mNumSetParametersCalls) {
+          mPendingParameters = Nothing();
+          // Ok, nothing has called SyncToJsep while this async task was
+          // pending. No need for special handling anymore.
+          mPendingRidChangeFromCompatMode = false;
+        }
+        MOZ_ASSERT(mParameters.mEncodings.Length());
+        // Resolve p with undefined.
+        p->MaybeResolveWithUndefined();
+      }));
+
+  // Return p.
+  return p.forget();
+}
+
+// static
+void RTCRtpSender::CheckAndRectifyEncodings(
+    Sequence<RTCRtpEncodingParameters>& aEncodings, bool aVideo,
+    ErrorResult& aRv) {
+  // If any encoding contains a rid member whose value does not conform to the
+  // grammar requirements specified in Section 10 of [RFC8851], throw a
+  // TypeError.
+  for (const auto& encoding : aEncodings) {
+    if (encoding.mRid.WasPassed()) {
+      std::string utf8Rid = NS_ConvertUTF16toUTF8(encoding.mRid.Value()).get();
+      std::string error;
+      if (!SdpRidAttributeList::CheckRidValidity(utf8Rid, &error)) {
+        aRv.ThrowTypeError(nsCString(error));
+        return;
+      }
+      if (utf8Rid.size() > SdpRidAttributeList::kMaxRidLength) {
+        std::ostringstream ss;
+        ss << "Rid can be at most " << SdpRidAttributeList::kMaxRidLength
+           << " characters long (due to internal limitations)";
+        aRv.ThrowTypeError(nsCString(ss.str()));
+        return;
+      }
+    }
+  }
+
+  if (aEncodings.Length() > 1) {
+    // If some but not all encodings contain a rid member, throw a TypeError.
+    // rid must be set if there is more than one encoding
+    // NOTE: Since rid is read-only, and the number of encodings cannot grow,
+    // this should never happen in setParameters.
+    for (const auto& encoding : aEncodings) {
+      if (!encoding.mRid.WasPassed()) {
+        aRv.ThrowTypeError("Missing rid");
+        return;
+      }
+    }
+
+    // If any encoding contains a rid member whose value is the same as that of
+    // a rid contained in another encoding in sendEncodings, throw a TypeError.
+    // NOTE: Since rid is read-only, and the number of encodings cannot grow,
+    // this should never happen in setParameters.
+    std::set<nsString> uniqueRids;
+    for (const auto& encoding : aEncodings) {
+      if (uniqueRids.count(encoding.mRid.Value())) {
+        aRv.ThrowTypeError("Duplicate rid");
+        return;
+      }
+      uniqueRids.insert(encoding.mRid.Value());
+    }
+  }
+  // TODO: ptime/adaptivePtime validation (bug 1733647)
+
+  // If kind is "audio", remove the scaleResolutionDownBy member from all
+  // encodings that contain one.
+  if (!aVideo) {
+    for (auto& encoding : aEncodings) {
+      if (encoding.mScaleResolutionDownBy.WasPassed()) {
+        encoding.mScaleResolutionDownBy.Reset();
+      }
+      if (encoding.mMaxFramerate.WasPassed()) {
+        encoding.mMaxFramerate.Reset();
+      }
+    }
+  }
+
+  // If any encoding contains a scaleResolutionDownBy member whose value is
+  // less than 1.0, throw a RangeError.
+  for (const auto& encoding : aEncodings) {
+    if (encoding.mScaleResolutionDownBy.WasPassed()) {
+      if (encoding.mScaleResolutionDownBy.Value() < 1.0f) {
+        aRv.ThrowRangeError("scaleResolutionDownBy must be >= 1.0");
+        return;
+      }
+    }
+  }
+
+  // Verify that the value of each maxFramerate member in sendEncodings that is
+  // defined is greater than 0.0. If one of the maxFramerate values does not
+  // meet this requirement, throw a RangeError.
+  for (const auto& encoding : aEncodings) {
+    if (encoding.mMaxFramerate.WasPassed()) {
+      if (encoding.mMaxFramerate.Value() < 0.0f) {
+        aRv.ThrowRangeError("maxFramerate must be non-negative");
+        return;
+      }
+    }
+  }
+}
+
+void RTCRtpSender::GetParameters(RTCRtpSendParameters& aParameters) {
+  MOZ_ASSERT(mParameters.mEncodings.Length());
+  // If sender.[[LastReturnedParameters]] is not null, return
+  // sender.[[LastReturnedParameters]], and abort these steps.
+  if (mLastReturnedParameters.isSome()) {
+    aParameters = *mLastReturnedParameters;
+    return;
+  }
+
+  // Let result be a new RTCRtpSendParameters dictionary constructed as follows:
+
+  // transactionId is set to a new unique identifier
+  aParameters.mTransactionId.Construct(mPc->GenerateUUID());
+
+  // encodings is set to the value of the [[SendEncodings]] internal slot.
+  aParameters.mEncodings = mParameters.mEncodings;
+
+  // The headerExtensions sequence is populated based on the header extensions
+  // that have been negotiated for sending
+  // TODO(bug 1765851): We do not support this yet
+  // aParameters.mHeaderExtensions.Construct();
+
+  // codecs is set to the value of the [[SendCodecs]] internal slot
+  // TODO(bug 1534687): We do not support this yet
+
+  // rtcp.cname is set to the CNAME of the associated RTCPeerConnection.
+  // rtcp.reducedSize is set to true if reduced-size RTCP has been negotiated
+  // for sending, and false otherwise.
+  // TODO(bug 1765852): We do not support this yet
+  aParameters.mRtcp.Construct();
+  aParameters.mRtcp.Value().mCname.Construct();
+  aParameters.mRtcp.Value().mReducedSize.Construct(false);
+  aParameters.mHeaderExtensions.Construct();
+  aParameters.mCodecs.Construct();
+
+  // Set sender.[[LastReturnedParameters]] to result.
+  mLastReturnedParameters = Some(aParameters);
+
+  // Queue a task that sets sender.[[LastReturnedParameters]] to null.
+  GetMainThreadSerialEventTarget()->Dispatch(NS_NewRunnableFunction(
+      __func__, [this, self = RefPtr<RTCRtpSender>(this)] {
+        mLastReturnedParameters = Nothing();
+      }));
+}
+
+bool operator==(const RTCRtpEncodingParameters& a1,
+                const RTCRtpEncodingParameters& a2) {
+  // webidl does not generate types that are equality comparable
+  return a1.mActive == a2.mActive && a1.mFec == a2.mFec &&
+         a1.mMaxBitrate == a2.mMaxBitrate &&
+         a1.mMaxFramerate == a2.mMaxFramerate && a1.mPriority == a2.mPriority &&
+         a1.mRid == a2.mRid && a1.mRtx == a2.mRtx &&
+         a1.mScaleResolutionDownBy == a2.mScaleResolutionDownBy &&
+         a1.mSsrc == a2.mSsrc;
+}
+
+// static
+void RTCRtpSender::ApplyJsEncodingToConduitEncoding(
+    const RTCRtpEncodingParameters& aJsEncoding,
+    VideoCodecConfig::Encoding* aConduitEncoding) {
+  aConduitEncoding->active = aJsEncoding.mActive;
+  if (aJsEncoding.mMaxBitrate.WasPassed()) {
+    aConduitEncoding->constraints.maxBr = aJsEncoding.mMaxBitrate.Value();
+  }
+  if (aJsEncoding.mMaxFramerate.WasPassed()) {
+    aConduitEncoding->constraints.maxFps =
+        Some(aJsEncoding.mMaxFramerate.Value());
+  }
+  if (aJsEncoding.mScaleResolutionDownBy.WasPassed()) {
+    // Optional does not have a valueOr, despite being based on Maybe
+    // :(
+    aConduitEncoding->constraints.scaleDownBy =
+        aJsEncoding.mScaleResolutionDownBy.Value();
+  } else {
+    aConduitEncoding->constraints.scaleDownBy = 1.0f;
+  }
+}
+
+void RTCRtpSender::UpdateRestorableEncodings(
+    const Sequence<RTCRtpEncodingParameters>& aEncodings) {
+  MOZ_ASSERT(aEncodings.Length());
+
+  if (GetJsepTransceiver().mSendTrack.GetNegotiatedDetails()) {
+    // Once initial negotiation completes, we are no longer allowed to restore
+    // the unicast encoding.
+    mUnicastEncoding.reset();
+  } else if (mParameters.mEncodings.Length() == 1 &&
+             !mParameters.mEncodings[0].mRid.WasPassed()) {
+    // If we have not completed the initial negotiation, and we currently are
+    // ridless unicast, we need to save our unicast encoding in case a
+    // rollback occurs.
+    mUnicastEncoding = Some(mParameters.mEncodings[0]);
+  }
+}
+
+Sequence<RTCRtpEncodingParameters> RTCRtpSender::ToSendEncodings(
+    const std::vector<std::string>& aRids) const {
+  MOZ_ASSERT(!aRids.empty());
+
+  Sequence<RTCRtpEncodingParameters> result;
+  // If sendEncodings is given as input to this algorithm, and is non-empty,
+  // set the [[SendEncodings]] slot to sendEncodings.
+  for (const auto& rid : aRids) {
+    MOZ_ASSERT(!rid.empty());
+    RTCRtpEncodingParameters encoding;
+    encoding.mActive = true;
+    encoding.mRid.Construct(NS_ConvertUTF8toUTF16(rid.c_str()));
+    Unused << result.AppendElement(encoding, fallible);
+  }
+
+  // If sendEncodings is non-empty, set each encoding's scaleResolutionDownBy
+  // to 2^(length of sendEncodings - encoding index - 1).
+  if (mTransceiver->IsVideo()) {
+    double scale = 1.0f;
+    for (auto it = result.rbegin(); it != result.rend(); ++it) {
+      it->mScaleResolutionDownBy.Construct(scale);
+      scale *= 2;
+    }
+  }
+
+  return result;
+}
+
+void RTCRtpSender::MaybeGetJsepRids() {
+  MOZ_ASSERT(!mSimulcastEnvelopeSet);
+  MOZ_ASSERT(mParameters.mEncodings.Length());
+
+  auto jsepRids = GetJsepTransceiver().mSendTrack.GetRids();
+  if (!jsepRids.empty()) {
+    UpdateRestorableEncodings(mParameters.mEncodings);
+    if (jsepRids.size() != 1 || !jsepRids[0].empty()) {
+      // JSEP is using at least one rid. Stomp our single ridless encoding
+      mParameters.mEncodings = ToSendEncodings(jsepRids);
+    }
+    mSimulcastEnvelopeSet = true;
+    mSimulcastEnvelopeSetByJSEP = true;
+  }
+}
+
+Sequence<RTCRtpEncodingParameters> RTCRtpSender::GetMatchingEncodings(
+    const std::vector<std::string>& aRids) const {
+  Sequence<RTCRtpEncodingParameters> result;
+
+  if (!aRids.empty() && !aRids[0].empty()) {
+    // Simulcast, or unicast with rid
+    for (const auto& encoding : mParameters.mEncodings) {
+      for (const auto& rid : aRids) {
+        auto utf16Rid = NS_ConvertUTF8toUTF16(rid.c_str());
+        if (!encoding.mRid.WasPassed() || (utf16Rid == encoding.mRid.Value())) {
+          auto encodingCopy(encoding);
+          if (!encodingCopy.mRid.WasPassed()) {
+            encodingCopy.mRid.Construct(NS_ConvertUTF8toUTF16(rid.c_str()));
+          }
+          Unused << result.AppendElement(encodingCopy, fallible);
+          break;
+        }
+      }
+    }
+  }
+
+  // If we're allowing the old setParameters behavior, we _might_ be able to
+  // get into this situation even if there were rids above. Be extra careful.
+  // Under normal circumstances, this just handles the ridless case.
+  if (!result.Length()) {
+    // Unicast with no specified rid. Restore mUnicastEncoding, if
+    // it exists, otherwise pick the first encoding.
+    if (mUnicastEncoding.isSome()) {
+      Unused << result.AppendElement(*mUnicastEncoding, fallible);
+    } else {
+      Unused << result.AppendElement(mParameters.mEncodings[0], fallible);
+    }
+  }
+
+  return result;
+}
+
+void RTCRtpSender::SetStreams(
+    const Sequence<OwningNonNull<DOMMediaStream>>& aStreams, ErrorResult& aRv) {
+  if (mPc->IsClosed()) {
+    aRv.ThrowInvalidStateError(
+        "Cannot call setStreams if the peer connection is closed");
+    return;
+  }
+
+  SetStreamsImpl(aStreams);
+  mPc->UpdateNegotiationNeeded();
+}
+
+void RTCRtpSender::SetStreamsImpl(
+    const Sequence<OwningNonNull<DOMMediaStream>>& aStreams) {
+  mStreams.Clear();
+  std::set<nsString> ids;
+  for (const auto& stream : aStreams) {
+    nsString id;
+    stream->GetId(id);
+    if (!ids.count(id)) {
+      ids.insert(id);
+      mStreams.AppendElement(stream);
+    }
+  }
+}
+
+void RTCRtpSender::GetStreams(nsTArray<RefPtr<DOMMediaStream>>& aStreams) {
+  aStreams = mStreams.Clone();
+}
+
+class ReplaceTrackOperation final : public PeerConnectionImpl::Operation {
+ public:
+  ReplaceTrackOperation(PeerConnectionImpl* aPc,
+                        const RefPtr<RTCRtpTransceiver>& aTransceiver,
+                        const RefPtr<MediaStreamTrack>& aTrack,
+                        ErrorResult& aError);
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(ReplaceTrackOperation,
+                                           PeerConnectionImpl::Operation)
+
+ private:
+  MOZ_CAN_RUN_SCRIPT
+  RefPtr<dom::Promise> CallImpl(ErrorResult& aError) override;
+  ~ReplaceTrackOperation() = default;
+  RefPtr<RTCRtpTransceiver> mTransceiver;
+  RefPtr<MediaStreamTrack> mNewTrack;
+};
+
+NS_IMPL_CYCLE_COLLECTION_INHERITED(ReplaceTrackOperation,
+                                   PeerConnectionImpl::Operation, mTransceiver,
+                                   mNewTrack)
+
+NS_IMPL_ADDREF_INHERITED(ReplaceTrackOperation, PeerConnectionImpl::Operation)
+NS_IMPL_RELEASE_INHERITED(ReplaceTrackOperation, PeerConnectionImpl::Operation)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(ReplaceTrackOperation)
+NS_INTERFACE_MAP_END_INHERITING(PeerConnectionImpl::Operation)
+
+ReplaceTrackOperation::ReplaceTrackOperation(
+    PeerConnectionImpl* aPc, const RefPtr<RTCRtpTransceiver>& aTransceiver,
+    const RefPtr<MediaStreamTrack>& aTrack, ErrorResult& aError)
+    : PeerConnectionImpl::Operation(aPc, aError),
+      mTransceiver(aTransceiver),
+      mNewTrack(aTrack) {}
+
+RefPtr<dom::Promise> ReplaceTrackOperation::CallImpl(ErrorResult& aError) {
+  RefPtr<RTCRtpSender> sender = mTransceiver->Sender();
+  // If transceiver.[[Stopped]] is true, return a promise rejected with a newly
+  // created InvalidStateError.
+  if (mTransceiver->Stopped()) {
+    RefPtr<dom::Promise> error = sender->MakePromise(aError);
+    if (aError.Failed()) {
+      return nullptr;
+    }
+    MOZ_LOG(gSenderLog, LogLevel::Debug,
+            ("%s Cannot call replaceTrack when transceiver is stopped",
+             __FUNCTION__));
+    error->MaybeRejectWithInvalidStateError(
+        "Cannot call replaceTrack when transceiver is stopped");
+    return error;
+  }
+
+  // Let p be a new promise.
+  RefPtr<dom::Promise> p = sender->MakePromise(aError);
+  if (aError.Failed()) {
+    return nullptr;
+  }
+
+  if (!sender->SeamlessTrackSwitch(mNewTrack)) {
+    MOZ_LOG(gSenderLog, LogLevel::Info,
+            ("%s Could not seamlessly replace track", __FUNCTION__));
+    p->MaybeRejectWithInvalidModificationError(
+        "Could not seamlessly replace track");
+    return p;
+  }
+
+  // Queue a task that runs the following steps:
+  GetMainThreadSerialEventTarget()->Dispatch(NS_NewRunnableFunction(
+      __func__, [p, sender, track = mNewTrack]() MOZ_CAN_RUN_SCRIPT_BOUNDARY {
+        // If connection.[[IsClosed]] is true, abort these steps.
+        // Set sender.[[SenderTrack]] to withTrack.
+        if (sender->SetSenderTrackWithClosedCheck(track)) {
+          // Resolve p with undefined.
+          p->MaybeResolveWithUndefined();
+        }
+      }));
+
+  // Return p.
+  return p;
+}
+
+already_AddRefed<dom::Promise> RTCRtpSender::ReplaceTrack(
+    dom::MediaStreamTrack* aWithTrack, ErrorResult& aError) {
+  // If withTrack is non-null and withTrack.kind differs from the transceiver
+  // kind of transceiver, return a promise rejected with a newly created
+  // TypeError.
+  if (aWithTrack) {
+    nsString newKind;
+    aWithTrack->GetKind(newKind);
+    nsString oldKind;
+    mTransceiver->GetKind(oldKind);
+    if (newKind != oldKind) {
+      RefPtr<dom::Promise> error = MakePromise(aError);
+      if (aError.Failed()) {
+        return nullptr;
+      }
+      error->MaybeRejectWithTypeError(
+          "Cannot replaceTrack with a different kind!");
+      return error.forget();
+    }
+  }
+
+  MOZ_LOG(gSenderLog, LogLevel::Debug,
+          ("%s[%s]: %s (%p to %p)", mPc->GetHandle().c_str(), GetMid().c_str(),
+           __FUNCTION__, mSenderTrack.get(), aWithTrack));
+
+  // Return the result of chaining the following steps to connection's
+  // operations chain:
+  RefPtr<PeerConnectionImpl::Operation> op =
+      new ReplaceTrackOperation(mPc, mTransceiver, aWithTrack, aError);
+  if (aError.Failed()) {
+    return nullptr;
+  }
+  // Static analysis forces us to use a temporary.
+  auto pc = mPc;
+  return pc->Chain(op, aError);
+}
+
+nsPIDOMWindowInner* RTCRtpSender::GetParentObject() const { return mWindow; }
+
+already_AddRefed<dom::Promise> RTCRtpSender::MakePromise(
+    ErrorResult& aError) const {
+  return mPc->MakePromise(aError);
+}
+
+bool RTCRtpSender::SeamlessTrackSwitch(
+    const RefPtr<MediaStreamTrack>& aWithTrack) {
+  // We do not actually update mSenderTrack here! Spec says that happens in a
+  // queued task after this is done (this happens in
+  // SetSenderTrackWithClosedCheck).
+
+  mPipeline->SetTrack(aWithTrack);
+
+  MaybeUpdateConduit();
+
+  // There may eventually be cases where a renegotiation is necessary to switch.
+  return true;
+}
+
+void RTCRtpSender::SetTrack(const RefPtr<MediaStreamTrack>& aTrack) {
+  // Used for RTCPeerConnection.removeTrack and RTCPeerConnection.addTrack
+  mSenderTrack = aTrack;
+  SeamlessTrackSwitch(aTrack);
+  if (aTrack) {
+    // RFC says (in the section on remote rollback):
+    // However, an RtpTransceiver MUST NOT be removed if a track was attached
+    // to the RtpTransceiver via the addTrack method.
+    mAddTrackCalled = true;
+  }
+}
+
+bool RTCRtpSender::SetSenderTrackWithClosedCheck(
+    const RefPtr<MediaStreamTrack>& aTrack) {
+  if (!mPc->IsClosed()) {
+    mSenderTrack = aTrack;
+    return true;
+  }
+
+  return false;
+}
+
+void RTCRtpSender::Shutdown() {
+  MOZ_ASSERT(NS_IsMainThread());
+  mWatchManager.Shutdown();
+  mPipeline->Shutdown();
+  mPipeline = nullptr;
+}
+
+void RTCRtpSender::BreakCycles() {
+  mWindow = nullptr;
+  mPc = nullptr;
+  mSenderTrack = nullptr;
+  mTransceiver = nullptr;
+  mStreams.Clear();
+  mDtmf = nullptr;
+}
+
+void RTCRtpSender::UpdateTransport() {
+  MOZ_ASSERT(NS_IsMainThread());
+  if (!mHaveSetupTransport) {
+    mPipeline->SetLevel(GetJsepTransceiver().GetLevel());
+    mHaveSetupTransport = true;
+  }
+
+  mPipeline->UpdateTransport_m(GetJsepTransceiver().mTransport.mTransportId,
+                               nullptr);
+}
+
+void RTCRtpSender::MaybeUpdateConduit() {
+  // NOTE(pkerr) - the Call API requires the both local_ssrc and remote_ssrc be
+  // set to a non-zero value or the CreateVideo...Stream call will fail.
+  if (NS_WARN_IF(GetJsepTransceiver().mSendTrack.GetSsrcs().empty())) {
+    MOZ_ASSERT(
+        false,
+        "No local ssrcs! This is a bug in the jsep engine, and should never "
+        "happen!");
+    return;
+  }
+
+  if (!mPipeline) {
+    return;
+  }
+
+  bool wasTransmitting = mTransmitting;
+
+  if (mPipeline->mConduit->type() == MediaSessionConduit::VIDEO) {
+    Maybe<VideoConfig> newConfig = GetNewVideoConfig();
+    if (newConfig.isSome()) {
+      ApplyVideoConfig(*newConfig);
+    }
+  } else {
+    Maybe<AudioConfig> newConfig = GetNewAudioConfig();
+    if (newConfig.isSome()) {
+      ApplyAudioConfig(*newConfig);
+    }
+  }
+
+  if (!mSenderTrack && !wasTransmitting && mTransmitting) {
+    MOZ_LOG(gSenderLog, LogLevel::Debug,
+            ("%s[%s]: %s Starting transmit conduit without send track!",
+             mPc->GetHandle().c_str(), GetMid().c_str(), __FUNCTION__));
+  }
+}
+
+void RTCRtpSender::SyncFromJsep(const JsepTransceiver& aJsepTransceiver) {
+  if (!mSimulcastEnvelopeSet) {
+    // JSEP is establishing the simulcast envelope for the first time, right now
+    // This is the addTrack (or addTransceiver without sendEncodings) case.
+    MaybeGetJsepRids();
+  } else if (!aJsepTransceiver.mSendTrack.GetNegotiatedDetails() ||
+             !aJsepTransceiver.mSendTrack.IsInHaveRemote()) {
+    // Spec says that we do not update our encodings until we're in stable,
+    // _unless_ this is the first negotiation.
+    std::vector<std::string> rids = aJsepTransceiver.mSendTrack.GetRids();
+    if (mSimulcastEnvelopeSetByJSEP && rids.empty()) {
+      // JSEP previously set the simulcast envelope, but now it has no opinion
+      // regarding unicast/simulcast. This can only happen on rollback of the
+      // initial remote offer.
+      mParameters.mEncodings = GetMatchingEncodings(rids);
+      MOZ_ASSERT(mParameters.mEncodings.Length());
+      mSimulcastEnvelopeSetByJSEP = false;
+      mSimulcastEnvelopeSet = false;
+    } else if (!rids.empty()) {
+      // JSEP has an opinion on the simulcast envelope, which trumps anything
+      // we have already.
+      mParameters.mEncodings = GetMatchingEncodings(rids);
+      MOZ_ASSERT(mParameters.mEncodings.Length());
+    }
+  }
+
+  MaybeUpdateConduit();
+}
+
+void RTCRtpSender::SyncToJsep(JsepTransceiver& aJsepTransceiver) const {
+  std::vector<std::string> streamIds;
+  for (const auto& stream : mStreams) {
+    nsString wideStreamId;
+    stream->GetId(wideStreamId);
+    std::string streamId = NS_ConvertUTF16toUTF8(wideStreamId).get();
+    MOZ_ASSERT(!streamId.empty());
+    streamIds.push_back(streamId);
+  }
+
+  aJsepTransceiver.mSendTrack.UpdateStreamIds(streamIds);
+
+  if (mSimulcastEnvelopeSet) {
+    std::vector<std::string> rids;
+    Maybe<RTCRtpSendParameters> parameters;
+    if (mPendingRidChangeFromCompatMode) {
+      // *sigh* If we have just let a setParameters change our rids, but we have
+      // not yet updated mParameters because the queued task hasn't run yet,
+      // we want to set the _new_ rids on the JsepTrack. So, we are forced to
+      // grab them from mPendingParameters.
+      parameters = mPendingParameters;
+    } else {
+      parameters = Some(mParameters);
+    }
+    for (const auto& encoding : parameters->mEncodings) {
+      if (encoding.mRid.WasPassed()) {
+        rids.push_back(NS_ConvertUTF16toUTF8(encoding.mRid.Value()).get());
+      } else {
+        rids.push_back("");
+      }
+    }
+
+    aJsepTransceiver.mSendTrack.SetRids(rids);
+  }
+
+  if (mTransceiver->IsVideo()) {
+    aJsepTransceiver.mSendTrack.SetMaxEncodings(webrtc::kMaxSimulcastStreams);
+  } else {
+    aJsepTransceiver.mSendTrack.SetMaxEncodings(1);
+  }
+
+  if (mAddTrackCalled) {
+    aJsepTransceiver.SetOnlyExistsBecauseOfSetRemote(false);
+  }
+}
+
+Maybe<RTCRtpSender::VideoConfig> RTCRtpSender::GetNewVideoConfig() {
+  // It is possible for SDP to signal that there is a send track, but there not
+  // actually be a send track, according to the specification; all that needs to
+  // happen is for the transceiver to be configured to send...
+  if (!GetJsepTransceiver().mSendTrack.GetNegotiatedDetails()) {
+    return Nothing();
+  }
+
+  VideoConfig oldConfig;
+  oldConfig.mSsrcs = mSsrcs;
+  oldConfig.mLocalRtpExtensions = mLocalRtpExtensions;
+  oldConfig.mCname = mCname;
+  oldConfig.mTransmitting = mTransmitting;
+  oldConfig.mVideoRtxSsrcs = mVideoRtxSsrcs;
+  oldConfig.mVideoCodec = mVideoCodec;
+  oldConfig.mVideoRtpRtcpConfig = mVideoRtpRtcpConfig;
+  oldConfig.mVideoCodecMode = mVideoCodecMode;
+
+  VideoConfig newConfig(oldConfig);
+
+  UpdateBaseConfig(&newConfig);
+
+  newConfig.mVideoRtxSsrcs = GetJsepTransceiver().mSendTrack.GetRtxSsrcs();
+
+  const JsepTrackNegotiatedDetails details(
+      *GetJsepTransceiver().mSendTrack.GetNegotiatedDetails());
+
+  if (mSenderTrack) {
+    RefPtr<mozilla::dom::VideoStreamTrack> videotrack =
+        mSenderTrack->AsVideoStreamTrack();
+
+    if (!videotrack) {
+      MOZ_CRASH(
+          "In ConfigureVideoCodecMode, mSenderTrack is not video! This should "
+          "never happen!");
+    }
+
+    dom::MediaSourceEnum source = videotrack->GetSource().GetMediaSource();
+    switch (source) {
+      case dom::MediaSourceEnum::Browser:
+      case dom::MediaSourceEnum::Screen:
+      case dom::MediaSourceEnum::Window:
+      case dom::MediaSourceEnum::Application:
+        newConfig.mVideoCodecMode = webrtc::VideoCodecMode::kScreensharing;
+        break;
+
+      case dom::MediaSourceEnum::Camera:
+      case dom::MediaSourceEnum::Other:
+        // Other is used by canvas capture, which we treat as realtime video.
+        // This seems debatable, but we've been doing it this way for a long
+        // time, so this is likely fine.
+        newConfig.mVideoCodecMode = webrtc::VideoCodecMode::kRealtimeVideo;
+        break;
+
+      case dom::MediaSourceEnum::Microphone:
+      case dom::MediaSourceEnum::AudioCapture:
+      case dom::MediaSourceEnum::EndGuard_:
+        MOZ_ASSERT(false);
+        break;
+    }
+  }
+
+  std::vector<VideoCodecConfig> configs;
+  RTCRtpTransceiver::NegotiatedDetailsToVideoCodecConfigs(details, &configs);
+
+  if (configs.empty()) {
+    // TODO: Are we supposed to plumb this error back to JS? This does not
+    // seem like a failure to set an answer, it just means that codec
+    // negotiation failed. For now, we're just doing the same thing we do
+    // if negotiation as a whole failed.
+    MOZ_LOG(gSenderLog, LogLevel::Error,
+            ("%s[%s]: %s  No video codecs were negotiated (send).",
+             mPc->GetHandle().c_str(), GetMid().c_str(), __FUNCTION__));
+    return Nothing();
+  }
+
+  newConfig.mVideoCodec = Some(configs[0]);
+  // Spec says that we start using new parameters right away, _before_ we
+  // update the parameters that are visible to JS (ie; mParameters).
+  const RTCRtpSendParameters& parameters =
+      mPendingParameters.isSome() ? *mPendingParameters : mParameters;
+  for (VideoCodecConfig::Encoding& conduitEncoding :
+       newConfig.mVideoCodec->mEncodings) {
+    for (const RTCRtpEncodingParameters& jsEncoding : parameters.mEncodings) {
+      std::string rid;
+      if (jsEncoding.mRid.WasPassed()) {
+        rid = NS_ConvertUTF16toUTF8(jsEncoding.mRid.Value()).get();
+      }
+      if (conduitEncoding.rid == rid) {
+        ApplyJsEncodingToConduitEncoding(jsEncoding, &conduitEncoding);
+        break;
+      }
+    }
+  }
+
+  newConfig.mVideoRtpRtcpConfig = Some(details.GetRtpRtcpConfig());
+
+  if (newConfig == oldConfig) {
+    MOZ_LOG(gSenderLog, LogLevel::Debug,
+            ("%s[%s]: %s  No change in video config", mPc->GetHandle().c_str(),
+             GetMid().c_str(), __FUNCTION__));
+    return Nothing();
+  }
+
+  if (newConfig.mVideoCodec.isSome()) {
+    MOZ_ASSERT(newConfig.mSsrcs.size() ==
+               newConfig.mVideoCodec->mEncodings.size());
+  }
+  return Some(newConfig);
+}
+
+Maybe<RTCRtpSender::AudioConfig> RTCRtpSender::GetNewAudioConfig() {
+  AudioConfig oldConfig;
+  oldConfig.mSsrcs = mSsrcs;
+  oldConfig.mLocalRtpExtensions = mLocalRtpExtensions;
+  oldConfig.mCname = mCname;
+  oldConfig.mTransmitting = mTransmitting;
+  oldConfig.mAudioCodec = mAudioCodec;
+
+  AudioConfig newConfig(oldConfig);
+
+  UpdateBaseConfig(&newConfig);
+
+  if (GetJsepTransceiver().mSendTrack.GetNegotiatedDetails() &&
+      GetJsepTransceiver().mSendTrack.GetActive()) {
+    const auto& details(
+        *GetJsepTransceiver().mSendTrack.GetNegotiatedDetails());
+
+    std::vector<AudioCodecConfig> configs;
+    RTCRtpTransceiver::NegotiatedDetailsToAudioCodecConfigs(details, &configs);
+    if (configs.empty()) {
+      // TODO: Are we supposed to plumb this error back to JS? This does not
+      // seem like a failure to set an answer, it just means that codec
+      // negotiation failed. For now, we're just doing the same thing we do
+      // if negotiation as a whole failed.
+      MOZ_LOG(gSenderLog, LogLevel::Error,
+              ("%s[%s]: %s No audio codecs were negotiated (send)",
+               mPc->GetHandle().c_str(), GetMid().c_str(), __FUNCTION__));
+      return Nothing();
+    }
+
+    std::vector<AudioCodecConfig> dtmfConfigs;
+    std::copy_if(
+        configs.begin(), configs.end(), std::back_inserter(dtmfConfigs),
+        [](const auto& value) { return value.mName == "telephone-event"; });
+
+    const AudioCodecConfig& sendCodec = configs[0];
+
+    if (!dtmfConfigs.empty()) {
+      // There is at least one telephone-event codec.
+      // We primarily choose the codec whose frequency matches the send codec.
+      // Secondarily we choose the one with the lowest frequency.
+      auto dtmfIterator =
+          std::find_if(dtmfConfigs.begin(), dtmfConfigs.end(),
+                       [&sendCodec](const auto& dtmfCodec) {
+                         return dtmfCodec.mFreq == sendCodec.mFreq;
+                       });
+      if (dtmfIterator == dtmfConfigs.end()) {
+        dtmfIterator = std::min_element(
+            dtmfConfigs.begin(), dtmfConfigs.end(),
+            [](const auto& a, const auto& b) { return a.mFreq < b.mFreq; });
+      }
+      MOZ_ASSERT(dtmfIterator != dtmfConfigs.end());
+      newConfig.mDtmfPt = dtmfIterator->mType;
+      newConfig.mDtmfFreq = dtmfIterator->mFreq;
+    }
+
+    newConfig.mAudioCodec = Some(sendCodec);
+  }
+
+  if (newConfig == oldConfig) {
+    MOZ_LOG(gSenderLog, LogLevel::Debug,
+            ("%s[%s]: %s  No change in audio config", mPc->GetHandle().c_str(),
+             GetMid().c_str(), __FUNCTION__));
+    return Nothing();
+  }
+
+  return Some(newConfig);
+}
+
+void RTCRtpSender::UpdateBaseConfig(BaseConfig* aConfig) {
+  aConfig->mSsrcs = GetJsepTransceiver().mSendTrack.GetSsrcs();
+  aConfig->mCname = GetJsepTransceiver().mSendTrack.GetCNAME();
+
+  if (GetJsepTransceiver().mSendTrack.GetNegotiatedDetails() &&
+      GetJsepTransceiver().mSendTrack.GetActive()) {
+    const auto& details(
+        *GetJsepTransceiver().mSendTrack.GetNegotiatedDetails());
+    {
+      std::vector<webrtc::RtpExtension> extmaps;
+      // @@NG read extmap from track
+      details.ForEachRTPHeaderExtension(
+          [&extmaps](const SdpExtmapAttributeList::Extmap& extmap) {
+            extmaps.emplace_back(extmap.extensionname, extmap.entry);
+          });
+      aConfig->mLocalRtpExtensions = extmaps;
+    }
+  }
+  // RTCRtpTransceiver::IsSending is updated after negotiation completes, in a
+  // queued task (which we may be in right now). Don't use
+  // JsepTrack::GetActive, because that updates before the queued task, which
+  // is too early for some of the things we interact with here (eg;
+  // RTCDTMFSender).
+  aConfig->mTransmitting = mTransceiver->IsSending();
+}
+
+void RTCRtpSender::ApplyVideoConfig(const VideoConfig& aConfig) {
+  if (aConfig.mVideoCodec.isSome()) {
+    MOZ_ASSERT(aConfig.mSsrcs.size() == aConfig.mVideoCodec->mEncodings.size());
+  }
+
+  mSsrcs = aConfig.mSsrcs;
+  mCname = aConfig.mCname;
+  mLocalRtpExtensions = aConfig.mLocalRtpExtensions;
+
+  mVideoRtxSsrcs = aConfig.mVideoRtxSsrcs;
+  mVideoCodec = aConfig.mVideoCodec;
+  mVideoRtpRtcpConfig = aConfig.mVideoRtpRtcpConfig;
+  mVideoCodecMode = aConfig.mVideoCodecMode;
+
+  mTransmitting = aConfig.mTransmitting;
+}
+
+void RTCRtpSender::ApplyAudioConfig(const AudioConfig& aConfig) {
+  mTransmitting = false;
+
+  mSsrcs = aConfig.mSsrcs;
+  mCname = aConfig.mCname;
+  mLocalRtpExtensions = aConfig.mLocalRtpExtensions;
+
+  mAudioCodec = aConfig.mAudioCodec;
+
+  if (aConfig.mDtmfPt >= 0) {
+    mDtmf->SetPayloadType(aConfig.mDtmfPt, aConfig.mDtmfFreq);
+  }
+
+  mTransmitting = aConfig.mTransmitting;
+}
+
+void RTCRtpSender::Stop() {
+  MOZ_ASSERT(mTransceiver->Stopped());
+  mTransmitting = false;
+}
+
+bool RTCRtpSender::HasTrack(const dom::MediaStreamTrack* aTrack) const {
+  if (!mSenderTrack) {
+    return false;
+  }
+
+  if (!aTrack) {
+    return true;
+  }
+
+  return mSenderTrack.get() == aTrack;
+}
+
+RefPtr<MediaPipelineTransmit> RTCRtpSender::GetPipeline() const {
+  return mPipeline;
+}
+
+std::string RTCRtpSender::GetMid() const { return mTransceiver->GetMidAscii(); }
+
+JsepTransceiver& RTCRtpSender::GetJsepTransceiver() {
+  return mTransceiver->GetJsepTransceiver();
+}
+
+void RTCRtpSender::UpdateDtmfSender() {
+  if (!mDtmf) {
+    return;
+  }
+
+  if (mTransmitting) {
+    return;
+  }
+
+  mDtmf->StopPlayout();
+}
+
+}  // namespace mozilla::dom
+
+#undef LOGTAG