summaryrefslogtreecommitdiffstats
path: root/dom/media/webrtc/jsapi/PeerConnectionImpl.cpp
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
commit26a029d407be480d791972afb5975cf62c9360a6 (patch)
treef435a8308119effd964b339f76abb83a57c29483 /dom/media/webrtc/jsapi/PeerConnectionImpl.cpp
parentInitial commit. (diff)
downloadfirefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz
firefox-26a029d407be480d791972afb5975cf62c9360a6.zip
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'dom/media/webrtc/jsapi/PeerConnectionImpl.cpp')
-rw-r--r--dom/media/webrtc/jsapi/PeerConnectionImpl.cpp4653
1 files changed, 4653 insertions, 0 deletions
diff --git a/dom/media/webrtc/jsapi/PeerConnectionImpl.cpp b/dom/media/webrtc/jsapi/PeerConnectionImpl.cpp
new file mode 100644
index 0000000000..985100153a
--- /dev/null
+++ b/dom/media/webrtc/jsapi/PeerConnectionImpl.cpp
@@ -0,0 +1,4653 @@
+/* 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 <cstdlib>
+#include <cerrno>
+#include <deque>
+#include <set>
+#include <sstream>
+#include <vector>
+
+#include "common/browser_logging/CSFLog.h"
+#include "base/histogram.h"
+#include "common/time_profiling/timecard.h"
+
+#include "jsapi.h"
+#include "nspr.h"
+#include "nss.h"
+#include "pk11pub.h"
+
+#include "nsNetCID.h"
+#include "nsIIDNService.h"
+#include "nsILoadContext.h"
+#include "nsEffectiveTLDService.h"
+#include "nsServiceManagerUtils.h"
+#include "nsThreadUtils.h"
+#include "nsIPrefService.h"
+#include "nsIPrefBranch.h"
+#include "nsProxyRelease.h"
+#include "prtime.h"
+
+#include "libwebrtcglue/AudioConduit.h"
+#include "libwebrtcglue/VideoConduit.h"
+#include "libwebrtcglue/WebrtcCallWrapper.h"
+#include "MediaTrackGraph.h"
+#include "transport/runnable_utils.h"
+#include "IPeerConnection.h"
+#include "PeerConnectionCtx.h"
+#include "PeerConnectionImpl.h"
+#include "RemoteTrackSource.h"
+#include "nsDOMDataChannelDeclarations.h"
+#include "transport/dtlsidentity.h"
+#include "sdp/SdpAttribute.h"
+
+#include "jsep/JsepTrack.h"
+#include "jsep/JsepSession.h"
+#include "jsep/JsepSessionImpl.h"
+
+#include "transportbridge/MediaPipeline.h"
+#include "transportbridge/RtpLogger.h"
+#include "jsapi/RTCRtpReceiver.h"
+#include "jsapi/RTCRtpSender.h"
+
+#include "mozilla/IntegerPrintfMacros.h"
+#include "mozilla/Sprintf.h"
+#include "mozilla/StaticPrefs_media.h"
+
+#ifdef XP_WIN
+// We need to undef the MS macro for Document::CreateEvent
+# ifdef CreateEvent
+# undef CreateEvent
+# endif
+#endif // XP_WIN
+
+#include "mozilla/dom/Document.h"
+#include "nsGlobalWindowInner.h"
+#include "nsDOMDataChannel.h"
+#include "mozilla/dom/Location.h"
+#include "mozilla/dom/Promise.h"
+#include "mozilla/NullPrincipal.h"
+#include "mozilla/TimeStamp.h"
+#include "mozilla/Telemetry.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/PublicSSL.h"
+#include "nsXULAppAPI.h"
+#include "nsContentUtils.h"
+#include "nsDOMJSUtils.h"
+#include "nsPrintfCString.h"
+#include "nsURLHelper.h"
+#include "nsNetUtil.h"
+#include "js/ArrayBuffer.h" // JS::NewArrayBufferWithContents
+#include "js/GCAnnotations.h" // JS_HAZ_ROOTED
+#include "js/RootingAPI.h" // JS::{{,Mutable}Handle,Rooted}
+#include "mozilla/PeerIdentity.h"
+#include "mozilla/dom/RTCCertificate.h"
+#include "mozilla/dom/RTCSctpTransportBinding.h" // RTCSctpTransportState
+#include "mozilla/dom/RTCDtlsTransportBinding.h" // RTCDtlsTransportState
+#include "mozilla/dom/RTCRtpReceiverBinding.h"
+#include "mozilla/dom/RTCRtpSenderBinding.h"
+#include "mozilla/dom/RTCStatsReportBinding.h"
+#include "mozilla/dom/RTCPeerConnectionBinding.h"
+#include "mozilla/dom/PeerConnectionImplBinding.h"
+#include "mozilla/dom/RTCDataChannelBinding.h"
+#include "mozilla/dom/PluginCrashedEvent.h"
+#include "MediaStreamTrack.h"
+#include "AudioStreamTrack.h"
+#include "VideoStreamTrack.h"
+#include "nsIScriptGlobalObject.h"
+#include "DOMMediaStream.h"
+#include "WebrtcGlobalInformation.h"
+#include "mozilla/dom/Event.h"
+#include "mozilla/EventDispatcher.h"
+#include "mozilla/net/DataChannelProtocol.h"
+#include "MediaManager.h"
+
+#include "transport/nr_socket_proxy_config.h"
+#include "RTCSctpTransport.h"
+#include "RTCDtlsTransport.h"
+#include "jsep/JsepTransport.h"
+
+#include "nsILoadInfo.h"
+#include "nsIPrincipal.h"
+#include "mozilla/LoadInfo.h"
+#include "nsIProxiedChannel.h"
+
+#include "mozilla/dom/BrowserChild.h"
+#include "mozilla/net/WebrtcProxyConfig.h"
+
+#ifdef XP_WIN
+// We need to undef the MS macro again in case the windows include file
+// got imported after we included mozilla/dom/Document.h
+# ifdef CreateEvent
+# undef CreateEvent
+# endif
+#endif // XP_WIN
+
+#include "MediaSegment.h"
+
+#ifdef USE_FAKE_PCOBSERVER
+# include "FakePCObserver.h"
+#else
+# include "mozilla/dom/PeerConnectionObserverBinding.h"
+#endif
+#include "mozilla/dom/PeerConnectionObserverEnumsBinding.h"
+
+#define ICE_PARSING \
+ "In RTCConfiguration passed to RTCPeerConnection constructor"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+
+typedef PCObserverString ObString;
+
+static const char* pciLogTag = "PeerConnectionImpl";
+#ifdef LOGTAG
+# undef LOGTAG
+#endif
+#define LOGTAG pciLogTag
+
+static mozilla::LazyLogModule logModuleInfo("signaling");
+
+// Getting exceptions back down from PCObserver is generally not harmful.
+namespace {
+// This is a terrible hack. The problem is that SuppressException is not
+// inline, and we link this file without libxul in some cases (e.g. for our test
+// setup). So we can't use ErrorResult or IgnoredErrorResult because those call
+// SuppressException... And we can't use FastErrorResult because we can't
+// include BindingUtils.h, because our linking is completely broken. Use
+// BaseErrorResult directly. Please do not let me see _anyone_ doing this
+// without really careful review from someone who knows what they are doing.
+class JSErrorResult : public binding_danger::TErrorResult<
+ binding_danger::JustAssertCleanupPolicy> {
+ public:
+ ~JSErrorResult() { SuppressException(); }
+} JS_HAZ_ROOTED;
+
+// The WrapRunnable() macros copy passed-in args and passes them to the function
+// later on the other thread. ErrorResult cannot be passed like this because it
+// disallows copy-semantics.
+//
+// This WrappableJSErrorResult hack solves this by not actually copying the
+// ErrorResult, but creating a new one instead, which works because we don't
+// care about the result.
+//
+// Since this is for JS-calls, these can only be dispatched to the main thread.
+
+class WrappableJSErrorResult {
+ public:
+ WrappableJSErrorResult() : mRv(MakeUnique<JSErrorResult>()), isCopy(false) {}
+ WrappableJSErrorResult(const WrappableJSErrorResult& other)
+ : mRv(MakeUnique<JSErrorResult>()), isCopy(true) {}
+ ~WrappableJSErrorResult() {
+ if (isCopy) {
+ MOZ_ASSERT(NS_IsMainThread());
+ }
+ }
+ operator ErrorResult&() { return *mRv; }
+
+ private:
+ mozilla::UniquePtr<JSErrorResult> mRv;
+ bool isCopy;
+} JS_HAZ_ROOTED;
+
+} // namespace
+
+static nsresult InitNSSInContent() {
+ NS_ENSURE_TRUE(NS_IsMainThread(), NS_ERROR_NOT_SAME_THREAD);
+
+ if (!XRE_IsContentProcess()) {
+ MOZ_ASSERT_UNREACHABLE("Must be called in content process");
+ return NS_ERROR_FAILURE;
+ }
+
+ static bool nssStarted = false;
+ if (nssStarted) {
+ return NS_OK;
+ }
+
+ if (NSS_NoDB_Init(nullptr) != SECSuccess) {
+ CSFLogError(LOGTAG, "NSS_NoDB_Init failed.");
+ return NS_ERROR_FAILURE;
+ }
+
+ if (NS_FAILED(mozilla::psm::InitializeCipherSuite())) {
+ CSFLogError(LOGTAG, "Fail to set up nss cipher suite.");
+ return NS_ERROR_FAILURE;
+ }
+
+ mozilla::psm::DisableMD5();
+
+ nssStarted = true;
+
+ return NS_OK;
+}
+
+namespace mozilla {
+class DataChannel;
+}
+
+namespace mozilla {
+
+void PeerConnectionAutoTimer::RegisterConnection() { mRefCnt++; }
+
+void PeerConnectionAutoTimer::UnregisterConnection(bool aContainedAV) {
+ MOZ_ASSERT(mRefCnt);
+ mRefCnt--;
+ mUsedAV |= aContainedAV;
+ if (mRefCnt == 0) {
+ if (mUsedAV) {
+ Telemetry::Accumulate(
+ Telemetry::WEBRTC_AV_CALL_DURATION,
+ static_cast<uint32_t>((TimeStamp::Now() - mStart).ToSeconds()));
+ }
+ Telemetry::Accumulate(
+ Telemetry::WEBRTC_CALL_DURATION,
+ static_cast<uint32_t>((TimeStamp::Now() - mStart).ToSeconds()));
+ }
+}
+
+bool PeerConnectionAutoTimer::IsStopped() { return mRefCnt == 0; }
+
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(PeerConnectionImpl)
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(PeerConnectionImpl)
+ tmp->Close();
+ tmp->BreakCycles();
+ NS_IMPL_CYCLE_COLLECTION_UNLINK(mPCObserver, mWindow, mCertificate,
+ mSTSThread, mReceiveStreams, mOperations,
+ mSctpTransport, mKungFuDeathGrip)
+ NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(PeerConnectionImpl)
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(
+ mPCObserver, mWindow, mCertificate, mSTSThread, mReceiveStreams,
+ mOperations, mTransceivers, mSctpTransport, mKungFuDeathGrip)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(PeerConnectionImpl)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(PeerConnectionImpl)
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(PeerConnectionImpl)
+ NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+ NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+
+already_AddRefed<PeerConnectionImpl> PeerConnectionImpl::Constructor(
+ const dom::GlobalObject& aGlobal) {
+ RefPtr<PeerConnectionImpl> pc = new PeerConnectionImpl(&aGlobal);
+
+ CSFLogDebug(LOGTAG, "Created PeerConnection: %p", pc.get());
+
+ return pc.forget();
+}
+
+JSObject* PeerConnectionImpl::WrapObject(JSContext* aCx,
+ JS::Handle<JSObject*> aGivenProto) {
+ return PeerConnectionImpl_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+nsPIDOMWindowInner* PeerConnectionImpl::GetParentObject() const {
+ return mWindow;
+}
+
+bool PCUuidGenerator::Generate(std::string* idp) {
+ nsresult rv;
+
+ if (!mGenerator) {
+ mGenerator = do_GetService("@mozilla.org/uuid-generator;1", &rv);
+ if (NS_FAILED(rv)) {
+ return false;
+ }
+ if (!mGenerator) {
+ return false;
+ }
+ }
+
+ nsID id;
+ rv = mGenerator->GenerateUUIDInPlace(&id);
+ if (NS_FAILED(rv)) {
+ return false;
+ }
+ char buffer[NSID_LENGTH];
+ id.ToProvidedString(buffer);
+ idp->assign(buffer);
+
+ return true;
+}
+
+bool IsPrivateBrowsing(nsPIDOMWindowInner* aWindow) {
+ if (!aWindow) {
+ return false;
+ }
+
+ Document* doc = aWindow->GetExtantDoc();
+ if (!doc) {
+ return false;
+ }
+
+ nsILoadContext* loadContext = doc->GetLoadContext();
+ return loadContext && loadContext->UsePrivateBrowsing();
+}
+
+PeerConnectionImpl::PeerConnectionImpl(const GlobalObject* aGlobal)
+ : mTimeCard(MOZ_LOG_TEST(logModuleInfo, LogLevel::Error) ? create_timecard()
+ : nullptr),
+ mSignalingState(RTCSignalingState::Stable),
+ mIceConnectionState(RTCIceConnectionState::New),
+ mIceGatheringState(RTCIceGatheringState::New),
+ mConnectionState(RTCPeerConnectionState::New),
+ mWindow(do_QueryInterface(aGlobal ? aGlobal->GetAsSupports() : nullptr)),
+ mCertificate(nullptr),
+ mSTSThread(nullptr),
+ mForceIceTcp(false),
+ mTransportHandler(nullptr),
+ mUuidGen(MakeUnique<PCUuidGenerator>()),
+ mIceRestartCount(0),
+ mIceRollbackCount(0),
+ mHaveConfiguredCodecs(false),
+ mTrickle(true) // TODO(ekr@rtfm.com): Use pref
+ ,
+ mPrivateWindow(false),
+ mActiveOnWindow(false),
+ mTimestampMaker(dom::RTCStatsTimestampMaker::Create(mWindow)),
+ mIdGenerator(new RTCStatsIdGenerator()),
+ listenPort(0),
+ connectPort(0),
+ connectStr(nullptr) {
+ MOZ_ASSERT(NS_IsMainThread());
+ MOZ_ASSERT_IF(aGlobal, mWindow);
+ mKungFuDeathGrip = this;
+ if (aGlobal) {
+ if (IsPrivateBrowsing(mWindow)) {
+ mPrivateWindow = true;
+ mDisableLongTermStats = true;
+ }
+ mWindow->AddPeerConnection();
+ mActiveOnWindow = true;
+
+ if (mWindow->GetDocumentURI()) {
+ mWindow->GetDocumentURI()->GetAsciiHost(mHostname);
+ nsresult rv;
+ nsCOMPtr<nsIEffectiveTLDService> eTLDService(
+ do_GetService(NS_EFFECTIVETLDSERVICE_CONTRACTID, &rv));
+ if (eTLDService) {
+ Unused << eTLDService->GetBaseDomain(mWindow->GetDocumentURI(), 0,
+ mEffectiveTLDPlus1);
+ }
+
+ mRtxIsAllowed = !HostnameInPref(
+ "media.peerconnection.video.use_rtx.blocklist", mHostname);
+ }
+ }
+
+ if (!mUuidGen->Generate(&mHandle)) {
+ MOZ_CRASH();
+ }
+
+ CSFLogInfo(LOGTAG, "%s: PeerConnectionImpl constructor for %s", __FUNCTION__,
+ mHandle.c_str());
+ STAMP_TIMECARD(mTimeCard, "Constructor Completed");
+ mForceIceTcp =
+ Preferences::GetBool("media.peerconnection.ice.force_ice_tcp", false);
+ memset(mMaxReceiving, 0, sizeof(mMaxReceiving));
+ memset(mMaxSending, 0, sizeof(mMaxSending));
+ mJsConfiguration.mCertificatesProvided = false;
+ mJsConfiguration.mPeerIdentityProvided = false;
+}
+
+PeerConnectionImpl::~PeerConnectionImpl() {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ MOZ_ASSERT(!mTransportHandler,
+ "PeerConnection should either be closed, or not initted in the "
+ "first place.");
+
+ if (mTimeCard) {
+ STAMP_TIMECARD(mTimeCard, "Destructor Invoked");
+ STAMP_TIMECARD(mTimeCard, mHandle.c_str());
+ print_timecard(mTimeCard);
+ destroy_timecard(mTimeCard);
+ mTimeCard = nullptr;
+ }
+
+ CSFLogInfo(LOGTAG, "%s: PeerConnectionImpl destructor invoked for %s",
+ __FUNCTION__, mHandle.c_str());
+}
+
+nsresult PeerConnectionImpl::Initialize(PeerConnectionObserver& aObserver,
+ nsGlobalWindowInner* aWindow) {
+ nsresult res;
+
+ MOZ_ASSERT(NS_IsMainThread());
+
+ mPCObserver = &aObserver;
+
+ // Find the STS thread
+
+ mSTSThread = do_GetService(NS_SOCKETTRANSPORTSERVICE_CONTRACTID, &res);
+ MOZ_ASSERT(mSTSThread);
+
+ // We do callback handling on STS instead of main to avoid media jank.
+ // Someday, we may have a dedicated thread for this.
+ mTransportHandler = MediaTransportHandler::Create(mSTSThread);
+ if (mPrivateWindow) {
+ mTransportHandler->EnterPrivateMode();
+ }
+
+ // Initialize NSS if we are in content process. For chrome process, NSS should
+ // already been initialized.
+ if (XRE_IsParentProcess()) {
+ // This code interferes with the C++ unit test startup code.
+ nsCOMPtr<nsISupports> nssDummy = do_GetService("@mozilla.org/psm;1", &res);
+ NS_ENSURE_SUCCESS(res, res);
+ } else {
+ NS_ENSURE_SUCCESS(res = InitNSSInContent(), res);
+ }
+
+ // Currently no standalone unit tests for DataChannel,
+ // which is the user of mWindow
+ MOZ_ASSERT(aWindow);
+ mWindow = aWindow;
+ NS_ENSURE_STATE(mWindow);
+
+ PRTime timestamp = PR_Now();
+ // Ok if we truncate this, but we want it to be large enough to reliably
+ // contain the location on the tests we run in CI.
+ char temp[256];
+
+ nsAutoCString locationCStr;
+
+ RefPtr<Location> location = mWindow->Location();
+ nsAutoString locationAStr;
+ res = location->ToString(locationAStr);
+ NS_ENSURE_SUCCESS(res, res);
+
+ CopyUTF16toUTF8(locationAStr, locationCStr);
+
+ SprintfLiteral(temp, "%s %" PRIu64 " (id=%" PRIu64 " url=%s)",
+ mHandle.c_str(), static_cast<uint64_t>(timestamp),
+ static_cast<uint64_t>(mWindow ? mWindow->WindowID() : 0),
+ locationCStr.get() ? locationCStr.get() : "NULL");
+
+ mName = temp;
+
+ STAMP_TIMECARD(mTimeCard, "Initializing PC Ctx");
+ res = PeerConnectionCtx::InitializeGlobal();
+ NS_ENSURE_SUCCESS(res, res);
+
+ mTransportHandler->CreateIceCtx("PC:" + GetName());
+
+ mJsepSession =
+ MakeUnique<JsepSessionImpl>(mName, MakeUnique<PCUuidGenerator>());
+ mJsepSession->SetRtxIsAllowed(mRtxIsAllowed);
+
+ res = mJsepSession->Init();
+ if (NS_FAILED(res)) {
+ CSFLogError(LOGTAG, "%s: Couldn't init JSEP Session, res=%u", __FUNCTION__,
+ static_cast<unsigned>(res));
+ return res;
+ }
+
+ std::vector<UniquePtr<JsepCodecDescription>> preferredCodecs;
+ SetupPreferredCodecs(preferredCodecs);
+ mJsepSession->SetDefaultCodecs(preferredCodecs);
+
+ std::vector<RtpExtensionHeader> preferredHeaders;
+ SetupPreferredRtpExtensions(preferredHeaders);
+
+ for (const auto& header : preferredHeaders) {
+ mJsepSession->AddRtpExtension(header.mMediaType, header.extensionname,
+ header.direction);
+ }
+
+ if (XRE_IsContentProcess()) {
+ mStunAddrsRequest =
+ new net::StunAddrsRequestChild(new StunAddrsHandler(this));
+ }
+
+ // Initialize the media object.
+ mForceProxy = ShouldForceProxy();
+
+ // We put this here, in case we later want to set this based on a non-standard
+ // param in RTCConfiguration.
+ mAllowOldSetParameters = Preferences::GetBool(
+ "media.peerconnection.allow_old_setParameters", false);
+
+ // setup the stun local addresses IPC async call
+ InitLocalAddrs();
+
+ mSignalHandler = MakeUnique<SignalHandler>(this, mTransportHandler.get());
+
+ PeerConnectionCtx::GetInstance()->AddPeerConnection(mHandle, this);
+
+ return NS_OK;
+}
+
+void PeerConnectionImpl::Initialize(PeerConnectionObserver& aObserver,
+ nsGlobalWindowInner& aWindow,
+ ErrorResult& rv) {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ nsresult res = Initialize(aObserver, &aWindow);
+ if (NS_FAILED(res)) {
+ rv.Throw(res);
+ return;
+ }
+}
+
+void PeerConnectionImpl::SetCertificate(
+ mozilla::dom::RTCCertificate& aCertificate) {
+ PC_AUTO_ENTER_API_CALL_NO_CHECK();
+ MOZ_ASSERT(!mCertificate, "This can only be called once");
+ mCertificate = &aCertificate;
+
+ std::vector<uint8_t> fingerprint;
+ nsresult rv =
+ CalculateFingerprint(DtlsIdentity::DEFAULT_HASH_ALGORITHM, &fingerprint);
+ if (NS_FAILED(rv)) {
+ CSFLogError(LOGTAG, "%s: Couldn't calculate fingerprint, rv=%u",
+ __FUNCTION__, static_cast<unsigned>(rv));
+ mCertificate = nullptr;
+ return;
+ }
+ rv = mJsepSession->AddDtlsFingerprint(DtlsIdentity::DEFAULT_HASH_ALGORITHM,
+ fingerprint);
+ if (NS_FAILED(rv)) {
+ CSFLogError(LOGTAG, "%s: Couldn't set DTLS credentials, rv=%u",
+ __FUNCTION__, static_cast<unsigned>(rv));
+ mCertificate = nullptr;
+ }
+
+ if (mUncommittedJsepSession) {
+ Unused << mUncommittedJsepSession->AddDtlsFingerprint(
+ DtlsIdentity::DEFAULT_HASH_ALGORITHM, fingerprint);
+ }
+}
+
+const RefPtr<mozilla::dom::RTCCertificate>& PeerConnectionImpl::Certificate()
+ const {
+ PC_AUTO_ENTER_API_CALL_NO_CHECK();
+ return mCertificate;
+}
+
+RefPtr<DtlsIdentity> PeerConnectionImpl::Identity() const {
+ PC_AUTO_ENTER_API_CALL_NO_CHECK();
+ MOZ_ASSERT(mCertificate);
+ return mCertificate->CreateDtlsIdentity();
+}
+
+class CompareCodecPriority {
+ public:
+ void SetPreferredCodec(int32_t preferredCodec) {
+ // This pref really ought to be a string, preferably something like
+ // "H264" or "VP8" instead of a payload type.
+ // Bug 1101259.
+ std::ostringstream os;
+ os << preferredCodec;
+ mPreferredCodec = os.str();
+ }
+
+ bool operator()(const UniquePtr<JsepCodecDescription>& lhs,
+ const UniquePtr<JsepCodecDescription>& rhs) const {
+ if (!mPreferredCodec.empty() && lhs->mDefaultPt == mPreferredCodec &&
+ rhs->mDefaultPt != mPreferredCodec) {
+ return true;
+ }
+
+ if (lhs->mStronglyPreferred && !rhs->mStronglyPreferred) {
+ return true;
+ }
+
+ return false;
+ }
+
+ private:
+ std::string mPreferredCodec;
+};
+
+class ConfigureCodec {
+ public:
+ explicit ConfigureCodec(nsCOMPtr<nsIPrefBranch>& branch)
+ : mHardwareH264Enabled(false),
+ mSoftwareH264Enabled(false),
+ mH264Enabled(false),
+ mVP9Enabled(true),
+ mVP9Preferred(false),
+ mH264Level(13), // minimum suggested for WebRTC spec
+ mH264MaxBr(0), // Unlimited
+ mH264MaxMbps(0), // Unlimited
+ mVP8MaxFs(0),
+ mVP8MaxFr(0),
+ mUseTmmbr(false),
+ mUseRemb(false),
+ mUseTransportCC(false),
+ mUseAudioFec(false),
+ mRedUlpfecEnabled(false) {
+ mSoftwareH264Enabled = PeerConnectionCtx::GetInstance()->gmpHasH264();
+
+ if (WebrtcVideoConduit::HasH264Hardware()) {
+ Telemetry::Accumulate(Telemetry::WEBRTC_HAS_H264_HARDWARE, true);
+ branch->GetBoolPref("media.webrtc.hw.h264.enabled",
+ &mHardwareH264Enabled);
+ }
+
+ mH264Enabled = mHardwareH264Enabled || mSoftwareH264Enabled;
+ Telemetry::Accumulate(Telemetry::WEBRTC_SOFTWARE_H264_ENABLED,
+ mSoftwareH264Enabled);
+ Telemetry::Accumulate(Telemetry::WEBRTC_HARDWARE_H264_ENABLED,
+ mHardwareH264Enabled);
+ Telemetry::Accumulate(Telemetry::WEBRTC_H264_ENABLED, mH264Enabled);
+
+ branch->GetIntPref("media.navigator.video.h264.level", &mH264Level);
+ mH264Level &= 0xFF;
+
+ branch->GetIntPref("media.navigator.video.h264.max_br", &mH264MaxBr);
+
+ branch->GetIntPref("media.navigator.video.h264.max_mbps", &mH264MaxMbps);
+
+ branch->GetBoolPref("media.peerconnection.video.vp9_enabled", &mVP9Enabled);
+
+ branch->GetBoolPref("media.peerconnection.video.vp9_preferred",
+ &mVP9Preferred);
+
+ branch->GetIntPref("media.navigator.video.max_fs", &mVP8MaxFs);
+ if (mVP8MaxFs <= 0) {
+ mVP8MaxFs = 12288; // We must specify something other than 0
+ }
+
+ branch->GetIntPref("media.navigator.video.max_fr", &mVP8MaxFr);
+ if (mVP8MaxFr <= 0) {
+ mVP8MaxFr = 60; // We must specify something other than 0
+ }
+
+ // TMMBR is enabled from a pref in about:config
+ branch->GetBoolPref("media.navigator.video.use_tmmbr", &mUseTmmbr);
+
+ // REMB is enabled by default, but can be disabled from about:config
+ branch->GetBoolPref("media.navigator.video.use_remb", &mUseRemb);
+
+ branch->GetBoolPref("media.navigator.video.use_transport_cc",
+ &mUseTransportCC);
+
+ branch->GetBoolPref("media.navigator.audio.use_fec", &mUseAudioFec);
+
+ branch->GetBoolPref("media.navigator.video.red_ulpfec_enabled",
+ &mRedUlpfecEnabled);
+ }
+
+ void operator()(UniquePtr<JsepCodecDescription>& codec) const {
+ switch (codec->Type()) {
+ case SdpMediaSection::kAudio: {
+ JsepAudioCodecDescription& audioCodec =
+ static_cast<JsepAudioCodecDescription&>(*codec);
+ if (audioCodec.mName == "opus") {
+ audioCodec.mFECEnabled = mUseAudioFec;
+ } else if (audioCodec.mName == "telephone-event") {
+ audioCodec.mEnabled = true;
+ }
+ } break;
+ case SdpMediaSection::kVideo: {
+ JsepVideoCodecDescription& videoCodec =
+ static_cast<JsepVideoCodecDescription&>(*codec);
+
+ if (videoCodec.mName == "H264") {
+ // Override level
+ videoCodec.mProfileLevelId &= 0xFFFF00;
+ videoCodec.mProfileLevelId |= mH264Level;
+
+ videoCodec.mConstraints.maxBr = mH264MaxBr;
+
+ videoCodec.mConstraints.maxMbps = mH264MaxMbps;
+
+ // Might disable it, but we set up other params anyway
+ videoCodec.mEnabled = mH264Enabled;
+
+ if (videoCodec.mPacketizationMode == 0 && !mSoftwareH264Enabled) {
+ // We're assuming packetization mode 0 is unsupported by
+ // hardware.
+ videoCodec.mEnabled = false;
+ }
+
+ if (mHardwareH264Enabled) {
+ videoCodec.mStronglyPreferred = true;
+ }
+ } else if (videoCodec.mName == "red") {
+ videoCodec.mEnabled = mRedUlpfecEnabled;
+ } else if (videoCodec.mName == "ulpfec") {
+ videoCodec.mEnabled = mRedUlpfecEnabled;
+ } else if (videoCodec.mName == "VP8" || videoCodec.mName == "VP9") {
+ if (videoCodec.mName == "VP9") {
+ if (!mVP9Enabled) {
+ videoCodec.mEnabled = false;
+ break;
+ }
+ if (mVP9Preferred) {
+ videoCodec.mStronglyPreferred = true;
+ }
+ }
+ videoCodec.mConstraints.maxFs = mVP8MaxFs;
+ videoCodec.mConstraints.maxFps = Some(mVP8MaxFr);
+ }
+
+ if (mUseTmmbr) {
+ videoCodec.EnableTmmbr();
+ }
+ if (mUseRemb) {
+ videoCodec.EnableRemb();
+ }
+ if (mUseTransportCC) {
+ videoCodec.EnableTransportCC();
+ }
+ } break;
+ case SdpMediaSection::kText:
+ case SdpMediaSection::kApplication:
+ case SdpMediaSection::kMessage: {
+ } // Nothing to configure for these.
+ }
+ }
+
+ private:
+ bool mHardwareH264Enabled;
+ bool mSoftwareH264Enabled;
+ bool mH264Enabled;
+ bool mVP9Enabled;
+ bool mVP9Preferred;
+ int32_t mH264Level;
+ int32_t mH264MaxBr;
+ int32_t mH264MaxMbps;
+ int32_t mVP8MaxFs;
+ int32_t mVP8MaxFr;
+ bool mUseTmmbr;
+ bool mUseRemb;
+ bool mUseTransportCC;
+ bool mUseAudioFec;
+ bool mRedUlpfecEnabled;
+};
+
+nsresult PeerConnectionImpl::ConfigureJsepSessionCodecs() {
+ nsresult res;
+ nsCOMPtr<nsIPrefService> prefs =
+ do_GetService("@mozilla.org/preferences-service;1", &res);
+
+ if (NS_FAILED(res)) {
+ CSFLogError(LOGTAG, "%s: Couldn't get prefs service, res=%u", __FUNCTION__,
+ static_cast<unsigned>(res));
+ return res;
+ }
+
+ nsCOMPtr<nsIPrefBranch> branch = do_QueryInterface(prefs);
+ if (!branch) {
+ CSFLogError(LOGTAG, "%s: Couldn't get prefs branch", __FUNCTION__);
+ return NS_ERROR_FAILURE;
+ }
+
+ ConfigureCodec configurer(branch);
+ mJsepSession->ForEachCodec(configurer);
+
+ // We use this to sort the list of codecs once everything is configured
+ CompareCodecPriority comparator;
+
+ // Sort by priority
+ int32_t preferredCodec = 0;
+ branch->GetIntPref("media.navigator.video.preferred_codec", &preferredCodec);
+
+ if (preferredCodec) {
+ comparator.SetPreferredCodec(preferredCodec);
+ }
+
+ mJsepSession->SortCodecs(comparator);
+ return NS_OK;
+}
+
+// Data channels won't work without a window, so in order for the C++ unit
+// tests to work (it doesn't have a window available) we ifdef the following
+// two implementations.
+//
+// Note: 'media.peerconnection.sctp.force_maximum_message_size' changes
+// behaviour triggered by these parameters.
+NS_IMETHODIMP
+PeerConnectionImpl::EnsureDataConnection(uint16_t aLocalPort,
+ uint16_t aNumstreams,
+ uint32_t aMaxMessageSize,
+ bool aMMSSet) {
+ PC_AUTO_ENTER_API_CALL(false);
+
+ if (mDataConnection) {
+ CSFLogDebug(LOGTAG, "%s DataConnection already connected", __FUNCTION__);
+ mDataConnection->SetMaxMessageSize(aMMSSet, aMaxMessageSize);
+ return NS_OK;
+ }
+
+ nsCOMPtr<nsISerialEventTarget> target = GetMainThreadSerialEventTarget();
+ Maybe<uint64_t> mms = aMMSSet ? Some(aMaxMessageSize) : Nothing();
+ if (auto res = DataChannelConnection::Create(this, target, mTransportHandler,
+ aLocalPort, aNumstreams, mms)) {
+ mDataConnection = res.value();
+ CSFLogDebug(LOGTAG, "%s DataChannelConnection %p attached to %s",
+ __FUNCTION__, (void*)mDataConnection.get(), mHandle.c_str());
+ return NS_OK;
+ }
+ CSFLogError(LOGTAG, "%s DataConnection Create Failed", __FUNCTION__);
+ return NS_ERROR_FAILURE;
+}
+
+nsresult PeerConnectionImpl::GetDatachannelParameters(
+ uint32_t* channels, uint16_t* localport, uint16_t* remoteport,
+ uint32_t* remotemaxmessagesize, bool* mmsset, std::string* transportId,
+ bool* client) const {
+ // Clear, just in case we fail.
+ *channels = 0;
+ *localport = 0;
+ *remoteport = 0;
+ *remotemaxmessagesize = 0;
+ *mmsset = false;
+ transportId->clear();
+
+ Maybe<const JsepTransceiver> datachannelTransceiver =
+ mJsepSession->FindTransceiver([](const JsepTransceiver& aTransceiver) {
+ return aTransceiver.GetMediaType() == SdpMediaSection::kApplication;
+ });
+
+ if (!datachannelTransceiver ||
+ !datachannelTransceiver->mTransport.mComponents ||
+ !datachannelTransceiver->mSendTrack.GetNegotiatedDetails()) {
+ return NS_ERROR_FAILURE;
+ }
+
+ // This will release assert if there is no such index, and that's ok
+ const JsepTrackEncoding& encoding =
+ datachannelTransceiver->mSendTrack.GetNegotiatedDetails()->GetEncoding(0);
+
+ if (NS_WARN_IF(encoding.GetCodecs().empty())) {
+ CSFLogError(LOGTAG,
+ "%s: Negotiated m=application with no codec. "
+ "This is likely to be broken.",
+ __FUNCTION__);
+ return NS_ERROR_FAILURE;
+ }
+
+ for (const auto& codec : encoding.GetCodecs()) {
+ if (codec->Type() != SdpMediaSection::kApplication) {
+ CSFLogError(LOGTAG,
+ "%s: Codec type for m=application was %u, this "
+ "is a bug.",
+ __FUNCTION__, static_cast<unsigned>(codec->Type()));
+ MOZ_ASSERT(false, "Codec for m=application was not \"application\"");
+ return NS_ERROR_FAILURE;
+ }
+
+ if (codec->mName != "webrtc-datachannel") {
+ CSFLogWarn(LOGTAG,
+ "%s: Codec for m=application was not "
+ "webrtc-datachannel (was instead %s). ",
+ __FUNCTION__, codec->mName.c_str());
+ continue;
+ }
+
+ if (codec->mChannels) {
+ *channels = codec->mChannels;
+ } else {
+ *channels = WEBRTC_DATACHANNEL_STREAMS_DEFAULT;
+ }
+ const JsepApplicationCodecDescription* appCodec =
+ static_cast<const JsepApplicationCodecDescription*>(codec.get());
+ *localport = appCodec->mLocalPort;
+ *remoteport = appCodec->mRemotePort;
+ *remotemaxmessagesize = appCodec->mRemoteMaxMessageSize;
+ *mmsset = appCodec->mRemoteMMSSet;
+ MOZ_ASSERT(!datachannelTransceiver->mTransport.mTransportId.empty());
+ *transportId = datachannelTransceiver->mTransport.mTransportId;
+ *client = datachannelTransceiver->mTransport.mDtls->GetRole() ==
+ JsepDtlsTransport::kJsepDtlsClient;
+ return NS_OK;
+ }
+ return NS_ERROR_FAILURE;
+}
+
+nsresult PeerConnectionImpl::AddRtpTransceiverToJsepSession(
+ JsepTransceiver& transceiver) {
+ nsresult res = ConfigureJsepSessionCodecs();
+ if (NS_FAILED(res)) {
+ CSFLogError(LOGTAG, "Failed to configure codecs");
+ return res;
+ }
+
+ mJsepSession->AddTransceiver(transceiver);
+ return NS_OK;
+}
+
+static Maybe<SdpMediaSection::MediaType> ToSdpMediaType(
+ const nsAString& aKind) {
+ if (aKind.EqualsASCII("audio")) {
+ return Some(SdpMediaSection::MediaType::kAudio);
+ } else if (aKind.EqualsASCII("video")) {
+ return Some(SdpMediaSection::MediaType::kVideo);
+ }
+ return Nothing();
+}
+
+already_AddRefed<RTCRtpTransceiver> PeerConnectionImpl::AddTransceiver(
+ const dom::RTCRtpTransceiverInit& aInit, const nsAString& aKind,
+ dom::MediaStreamTrack* aSendTrack, bool aAddTrackMagic, ErrorResult& aRv) {
+ // Copy, because we might need to modify
+ RTCRtpTransceiverInit init(aInit);
+
+ Maybe<SdpMediaSection::MediaType> type = ToSdpMediaType(aKind);
+ if (NS_WARN_IF(!type.isSome())) {
+ MOZ_ASSERT(false, "Invalid media kind");
+ aRv = NS_ERROR_INVALID_ARG;
+ return nullptr;
+ }
+
+ JsepTransceiver jsepTransceiver(*type, *mUuidGen);
+ jsepTransceiver.SetRtxIsAllowed(mRtxIsAllowed);
+
+ // Do this last, since it is not possible to roll back.
+ nsresult rv = AddRtpTransceiverToJsepSession(jsepTransceiver);
+ if (NS_FAILED(rv)) {
+ CSFLogError(LOGTAG, "%s: AddRtpTransceiverToJsepSession failed, res=%u",
+ __FUNCTION__, static_cast<unsigned>(rv));
+ aRv = rv;
+ return nullptr;
+ }
+
+ auto& sendEncodings = init.mSendEncodings;
+
+ // CheckAndRectifyEncodings covers these six:
+ // 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.
+
+ // If some but not all encodings contain a rid member, throw a TypeError.
+
+ // 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.
+
+ // If kind is "audio", remove the scaleResolutionDownBy member from all
+ // encodings that contain one.
+
+ // If any encoding contains a scaleResolutionDownBy member whose value is
+ // less than 1.0, throw a RangeError.
+
+ // 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.
+ RTCRtpSender::CheckAndRectifyEncodings(sendEncodings,
+ *type == SdpMediaSection::kVideo, aRv);
+ if (aRv.Failed()) {
+ return nullptr;
+ }
+
+ // If any encoding contains a read-only parameter other than rid, throw an
+ // InvalidAccessError.
+ // NOTE: We don't support any additional read-only params right now. Also,
+ // spec shoehorns this in between checks that setParameters also performs
+ // (between the rid checks and the scaleResolutionDownBy checks).
+
+ // If any encoding contains a scaleResolutionDownBy member, then for each
+ // encoding without one, add a scaleResolutionDownBy member with the value
+ // 1.0.
+ for (const auto& constEncoding : sendEncodings) {
+ if (constEncoding.mScaleResolutionDownBy.WasPassed()) {
+ for (auto& encoding : sendEncodings) {
+ if (!encoding.mScaleResolutionDownBy.WasPassed()) {
+ encoding.mScaleResolutionDownBy.Construct(1.0f);
+ }
+ }
+ break;
+ }
+ }
+
+ // Let maxN be the maximum number of total simultaneous encodings the user
+ // agent may support for this kind, at minimum 1.This should be an optimistic
+ // number since the codec to be used is not known yet.
+ size_t maxN =
+ (*type == SdpMediaSection::kVideo) ? webrtc::kMaxSimulcastStreams : 1;
+
+ // If the number of encodings stored in sendEncodings exceeds maxN, then trim
+ // sendEncodings from the tail until its length is maxN.
+ // NOTE: Spec has this after all validation steps; even if there are elements
+ // that we will trim off, we still validate them.
+ if (sendEncodings.Length() > maxN) {
+ sendEncodings.TruncateLength(maxN);
+ }
+
+ // If kind is "video" and none of the encodings contain a
+ // scaleResolutionDownBy member, then for each encoding, add a
+ // scaleResolutionDownBy member with the value 2^(length of sendEncodings -
+ // encoding index - 1). This results in smaller-to-larger resolutions where
+ // the last encoding has no scaling applied to it, e.g. 4:2:1 if the length
+ // is 3.
+ // NOTE: The code above ensures that these are all set, or all unset, so we
+ // can just check the first one.
+ if (sendEncodings.Length() && *type == SdpMediaSection::kVideo &&
+ !sendEncodings[0].mScaleResolutionDownBy.WasPassed()) {
+ double scale = 1.0f;
+ for (auto it = sendEncodings.rbegin(); it != sendEncodings.rend(); ++it) {
+ it->mScaleResolutionDownBy.Construct(scale);
+ scale *= 2;
+ }
+ }
+
+ // If the number of encodings now stored in sendEncodings is 1, then remove
+ // any rid member from the lone entry.
+ if (sendEncodings.Length() == 1) {
+ sendEncodings[0].mRid.Reset();
+ }
+
+ RefPtr<RTCRtpTransceiver> transceiver = CreateTransceiver(
+ jsepTransceiver.GetUuid(),
+ jsepTransceiver.GetMediaType() == SdpMediaSection::kVideo, init,
+ aSendTrack, aAddTrackMagic, aRv);
+
+ if (aRv.Failed()) {
+ // Would be nice if we could peek at the rv without stealing it, so we
+ // could log...
+ CSFLogError(LOGTAG, "%s: failed", __FUNCTION__);
+ return nullptr;
+ }
+
+ mTransceivers.AppendElement(transceiver);
+ return transceiver.forget();
+}
+
+bool PeerConnectionImpl::CheckNegotiationNeeded() {
+ MOZ_ASSERT(mSignalingState == RTCSignalingState::Stable);
+ SyncToJsep();
+ return !mLocalIceCredentialsToReplace.empty() ||
+ mJsepSession->CheckNegotiationNeeded();
+}
+
+bool PeerConnectionImpl::CreatedSender(const dom::RTCRtpSender& aSender) const {
+ return aSender.IsMyPc(this);
+}
+
+nsresult PeerConnectionImpl::InitializeDataChannel() {
+ PC_AUTO_ENTER_API_CALL(false);
+ CSFLogDebug(LOGTAG, "%s", __FUNCTION__);
+
+ uint32_t channels = 0;
+ uint16_t localport = 0;
+ uint16_t remoteport = 0;
+ uint32_t remotemaxmessagesize = 0;
+ bool mmsset = false;
+ std::string transportId;
+ bool client = false;
+ nsresult rv = GetDatachannelParameters(&channels, &localport, &remoteport,
+ &remotemaxmessagesize, &mmsset,
+ &transportId, &client);
+
+ if (NS_FAILED(rv)) {
+ CSFLogDebug(LOGTAG, "%s: We did not negotiate datachannel", __FUNCTION__);
+ return NS_OK;
+ }
+
+ if (channels > MAX_NUM_STREAMS) {
+ channels = MAX_NUM_STREAMS;
+ }
+
+ rv = EnsureDataConnection(localport, channels, remotemaxmessagesize, mmsset);
+ if (NS_SUCCEEDED(rv)) {
+ if (mDataConnection->ConnectToTransport(transportId, client, localport,
+ remoteport)) {
+ return NS_OK;
+ }
+ // If we inited the DataConnection, call Destroy() before releasing it
+ mDataConnection->Destroy();
+ }
+ mDataConnection = nullptr;
+ return NS_ERROR_FAILURE;
+}
+
+already_AddRefed<nsDOMDataChannel> PeerConnectionImpl::CreateDataChannel(
+ const nsAString& aLabel, const nsAString& aProtocol, uint16_t aType,
+ bool ordered, uint16_t aMaxTime, uint16_t aMaxNum, bool aExternalNegotiated,
+ uint16_t aStream, ErrorResult& rv) {
+ RefPtr<nsDOMDataChannel> result;
+ rv = CreateDataChannel(aLabel, aProtocol, aType, ordered, aMaxTime, aMaxNum,
+ aExternalNegotiated, aStream, getter_AddRefs(result));
+ return result.forget();
+}
+
+NS_IMETHODIMP
+PeerConnectionImpl::CreateDataChannel(
+ const nsAString& aLabel, const nsAString& aProtocol, uint16_t aType,
+ bool ordered, uint16_t aMaxTime, uint16_t aMaxNum, bool aExternalNegotiated,
+ uint16_t aStream, nsDOMDataChannel** aRetval) {
+ PC_AUTO_ENTER_API_CALL(false);
+ MOZ_ASSERT(aRetval);
+
+ RefPtr<DataChannel> dataChannel;
+ DataChannelReliabilityPolicy prPolicy;
+ switch (aType) {
+ case IPeerConnection::kDataChannelReliable:
+ prPolicy = DataChannelReliabilityPolicy::Reliable;
+ break;
+ case IPeerConnection::kDataChannelPartialReliableRexmit:
+ prPolicy = DataChannelReliabilityPolicy::LimitedRetransmissions;
+ break;
+ case IPeerConnection::kDataChannelPartialReliableTimed:
+ prPolicy = DataChannelReliabilityPolicy::LimitedLifetime;
+ break;
+ default:
+ MOZ_ASSERT(false);
+ return NS_ERROR_FAILURE;
+ }
+
+ nsresult rv = EnsureDataConnection(
+ WEBRTC_DATACHANNEL_PORT_DEFAULT, WEBRTC_DATACHANNEL_STREAMS_DEFAULT,
+ WEBRTC_DATACHANNEL_MAX_MESSAGE_SIZE_REMOTE_DEFAULT, false);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+ dataChannel = mDataConnection->Open(
+ NS_ConvertUTF16toUTF8(aLabel), NS_ConvertUTF16toUTF8(aProtocol), prPolicy,
+ ordered,
+ prPolicy == DataChannelReliabilityPolicy::LimitedRetransmissions
+ ? aMaxNum
+ : (prPolicy == DataChannelReliabilityPolicy::LimitedLifetime
+ ? aMaxTime
+ : 0),
+ nullptr, nullptr, aExternalNegotiated, aStream);
+ NS_ENSURE_TRUE(dataChannel, NS_ERROR_NOT_AVAILABLE);
+
+ CSFLogDebug(LOGTAG, "%s: making DOMDataChannel", __FUNCTION__);
+
+ Maybe<JsepTransceiver> dcTransceiver =
+ mJsepSession->FindTransceiver([](const JsepTransceiver& aTransceiver) {
+ return aTransceiver.GetMediaType() == SdpMediaSection::kApplication;
+ });
+
+ if (dcTransceiver) {
+ dcTransceiver->RestartDatachannelTransceiver();
+ mJsepSession->SetTransceiver(*dcTransceiver);
+ } else {
+ mJsepSession->AddTransceiver(
+ JsepTransceiver(SdpMediaSection::MediaType::kApplication, *mUuidGen));
+ }
+
+ RefPtr<nsDOMDataChannel> retval;
+ rv = NS_NewDOMDataChannel(dataChannel.forget(), mWindow,
+ getter_AddRefs(retval));
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+ retval.forget(aRetval);
+ return NS_OK;
+}
+
+NS_IMPL_CYCLE_COLLECTION(PeerConnectionImpl::Operation, mPromise, mPc)
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(PeerConnectionImpl::Operation)
+ NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+NS_IMPL_CYCLE_COLLECTING_ADDREF(PeerConnectionImpl::Operation)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(PeerConnectionImpl::Operation)
+
+PeerConnectionImpl::Operation::Operation(PeerConnectionImpl* aPc,
+ ErrorResult& aError)
+ : mPromise(aPc->MakePromise(aError)), mPc(aPc) {}
+
+PeerConnectionImpl::Operation::~Operation() = default;
+
+void PeerConnectionImpl::Operation::Call(ErrorResult& aError) {
+ RefPtr<dom::Promise> opPromise = CallImpl(aError);
+ if (aError.Failed()) {
+ return;
+ }
+ // Upon fulfillment or rejection of the promise returned by the operation,
+ // run the following steps:
+ // (NOTE: mPromise is p from https://w3c.github.io/webrtc-pc/#dfn-chain,
+ // and CallImpl() is what returns the promise for the operation itself)
+ opPromise->AppendNativeHandler(this);
+}
+
+void PeerConnectionImpl::Operation::ResolvedCallback(
+ JSContext* aCx, JS::Handle<JS::Value> aValue, ErrorResult& aRv) {
+ // If connection.[[IsClosed]] is true, abort these steps.
+ // (the spec wants p to never settle in this event)
+ if (!mPc->IsClosed()) {
+ // If the promise returned by operation was fulfilled with a
+ // value, fulfill p with that value.
+ mPromise->MaybeResolveWithClone(aCx, aValue);
+ // Upon fulfillment or rejection of p, execute the following
+ // steps:
+ // (Static analysis forces us to use a temporary)
+ RefPtr<PeerConnectionImpl> pc = mPc;
+ pc->RunNextOperation(aRv);
+ }
+}
+
+void PeerConnectionImpl::Operation::RejectedCallback(
+ JSContext* aCx, JS::Handle<JS::Value> aValue, ErrorResult& aRv) {
+ // If connection.[[IsClosed]] is true, abort these steps.
+ // (the spec wants p to never settle in this event)
+ if (!mPc->IsClosed()) {
+ // If the promise returned by operation was rejected with a
+ // value, reject p with that value.
+ mPromise->MaybeRejectWithClone(aCx, aValue);
+ // Upon fulfillment or rejection of p, execute the following
+ // steps:
+ // (Static analysis forces us to use a temporary)
+ RefPtr<PeerConnectionImpl> pc = mPc;
+ pc->RunNextOperation(aRv);
+ }
+}
+
+NS_IMPL_CYCLE_COLLECTION_INHERITED(PeerConnectionImpl::JSOperation,
+ PeerConnectionImpl::Operation, mOperation)
+
+NS_IMPL_ADDREF_INHERITED(PeerConnectionImpl::JSOperation,
+ PeerConnectionImpl::Operation)
+NS_IMPL_RELEASE_INHERITED(PeerConnectionImpl::JSOperation,
+ PeerConnectionImpl::Operation)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(PeerConnectionImpl::JSOperation)
+NS_INTERFACE_MAP_END_INHERITING(PeerConnectionImpl::Operation)
+
+PeerConnectionImpl::JSOperation::JSOperation(PeerConnectionImpl* aPc,
+ dom::ChainedOperation& aOp,
+ ErrorResult& aError)
+ : Operation(aPc, aError), mOperation(&aOp) {}
+
+RefPtr<dom::Promise> PeerConnectionImpl::JSOperation::CallImpl(
+ ErrorResult& aError) {
+ // Static analysis will not let us call this without a temporary :(
+ RefPtr<dom::ChainedOperation> op = mOperation;
+ return op->Call(aError);
+}
+
+already_AddRefed<dom::Promise> PeerConnectionImpl::Chain(
+ dom::ChainedOperation& aOperation, ErrorResult& aError) {
+ MOZ_RELEASE_ASSERT(!mChainingOperation);
+ mChainingOperation = true;
+ RefPtr<Operation> operation = new JSOperation(this, aOperation, aError);
+ if (aError.Failed()) {
+ return nullptr;
+ }
+ RefPtr<Promise> promise = Chain(operation, aError);
+ if (aError.Failed()) {
+ return nullptr;
+ }
+ mChainingOperation = false;
+ return promise.forget();
+}
+
+// This is kinda complicated, but it is what the spec requires us to do. The
+// core of what makes this complicated is the requirement that |aOperation| be
+// run _immediately_ (without any Promise.Then!) if the operations chain is
+// empty.
+already_AddRefed<dom::Promise> PeerConnectionImpl::Chain(
+ const RefPtr<Operation>& aOperation, ErrorResult& aError) {
+ // If connection.[[IsClosed]] is true, return a promise rejected with a newly
+ // created InvalidStateError.
+ if (IsClosed()) {
+ CSFLogDebug(LOGTAG, "%s:%d: Peer connection is closed", __FILE__, __LINE__);
+ RefPtr<dom::Promise> error = MakePromise(aError);
+ if (aError.Failed()) {
+ return nullptr;
+ }
+ error->MaybeRejectWithInvalidStateError("Peer connection is closed");
+ return error.forget();
+ }
+
+ // Append operation to [[Operations]].
+ mOperations.AppendElement(aOperation);
+
+ // If the length of [[Operations]] is exactly 1, execute operation.
+ if (mOperations.Length() == 1) {
+ aOperation->Call(aError);
+ if (aError.Failed()) {
+ return nullptr;
+ }
+ }
+
+ // This is the promise p from https://w3c.github.io/webrtc-pc/#dfn-chain
+ return do_AddRef(aOperation->GetPromise());
+}
+
+void PeerConnectionImpl::RunNextOperation(ErrorResult& aError) {
+ // If connection.[[IsClosed]] is true, abort these steps.
+ if (IsClosed()) {
+ return;
+ }
+
+ // Remove the first element of [[Operations]].
+ mOperations.RemoveElementAt(0);
+
+ // If [[Operations]] is non-empty, execute the operation represented by the
+ // first element of [[Operations]], and abort these steps.
+ if (mOperations.Length()) {
+ // Cannot call without a temporary :(
+ RefPtr<Operation> op = mOperations[0];
+ op->Call(aError);
+ return;
+ }
+
+ // If connection.[[UpdateNegotiationNeededFlagOnEmptyChain]] is false, abort
+ // these steps.
+ if (!mUpdateNegotiationNeededFlagOnEmptyChain) {
+ return;
+ }
+
+ // Set connection.[[UpdateNegotiationNeededFlagOnEmptyChain]] to false.
+ mUpdateNegotiationNeededFlagOnEmptyChain = false;
+ // Update the negotiation-needed flag for connection.
+ UpdateNegotiationNeeded();
+}
+
+void PeerConnectionImpl::SyncToJsep() {
+ for (const auto& transceiver : mTransceivers) {
+ transceiver->SyncToJsep(*mJsepSession);
+ }
+}
+
+void PeerConnectionImpl::SyncFromJsep() {
+ CSFLogDebug(LOGTAG, "%s", __FUNCTION__);
+ mJsepSession->ForEachTransceiver(
+ [this, self = RefPtr<PeerConnectionImpl>(this)](
+ const JsepTransceiver& jsepTransceiver) {
+ if (jsepTransceiver.GetMediaType() ==
+ SdpMediaSection::MediaType::kApplication) {
+ return;
+ }
+
+ CSFLogDebug(LOGTAG, "%s: Looking for match", __FUNCTION__);
+ RefPtr<RTCRtpTransceiver> transceiver;
+ for (auto& temp : mTransceivers) {
+ if (temp->GetJsepTransceiverId() == jsepTransceiver.GetUuid()) {
+ CSFLogDebug(LOGTAG, "%s: Found match", __FUNCTION__);
+ transceiver = temp;
+ break;
+ }
+ }
+
+ if (!transceiver) {
+ if (jsepTransceiver.IsRemoved()) {
+ return;
+ }
+ CSFLogDebug(LOGTAG, "%s: No match, making new", __FUNCTION__);
+ dom::RTCRtpTransceiverInit init;
+ init.mDirection = RTCRtpTransceiverDirection::Recvonly;
+ IgnoredErrorResult rv;
+ transceiver = CreateTransceiver(
+ jsepTransceiver.GetUuid(),
+ jsepTransceiver.GetMediaType() == SdpMediaSection::kVideo, init,
+ nullptr, false, rv);
+ if (NS_WARN_IF(rv.Failed())) {
+ MOZ_ASSERT(false);
+ return;
+ }
+ mTransceivers.AppendElement(transceiver);
+ }
+
+ CSFLogDebug(LOGTAG, "%s: Syncing transceiver", __FUNCTION__);
+ transceiver->SyncFromJsep(*mJsepSession);
+ });
+}
+
+already_AddRefed<dom::Promise> PeerConnectionImpl::MakePromise(
+ ErrorResult& aError) const {
+ nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(mWindow);
+ return dom::Promise::Create(global, aError);
+}
+
+void PeerConnectionImpl::UpdateNegotiationNeeded() {
+ // If the length of connection.[[Operations]] is not 0, then set
+ // connection.[[UpdateNegotiationNeededFlagOnEmptyChain]] to true, and abort
+ // these steps.
+ if (mOperations.Length() != 0) {
+ mUpdateNegotiationNeededFlagOnEmptyChain = true;
+ return;
+ }
+
+ // Queue a task to run the following steps:
+ GetMainThreadSerialEventTarget()->Dispatch(NS_NewRunnableFunction(
+ __func__, [this, self = RefPtr<PeerConnectionImpl>(this)] {
+ // If connection.[[IsClosed]] is true, abort these steps.
+ if (IsClosed()) {
+ return;
+ }
+ // If the length of connection.[[Operations]] is not 0, then set
+ // connection.[[UpdateNegotiationNeededFlagOnEmptyChain]] to true, and
+ // abort these steps.
+ if (mOperations.Length()) {
+ mUpdateNegotiationNeededFlagOnEmptyChain = true;
+ return;
+ }
+ // If connection's signaling state is not "stable", abort these steps.
+ if (mSignalingState != RTCSignalingState::Stable) {
+ return;
+ }
+ // If the result of checking if negotiation is needed is false, clear
+ // the negotiation-needed flag by setting
+ // connection.[[NegotiationNeeded]] to false, and abort these steps.
+ if (!CheckNegotiationNeeded()) {
+ mNegotiationNeeded = false;
+ return;
+ }
+
+ // If connection.[[NegotiationNeeded]] is already true, abort these
+ // steps.
+ if (mNegotiationNeeded) {
+ return;
+ }
+
+ // Set connection.[[NegotiationNeeded]] to true.
+ mNegotiationNeeded = true;
+
+ // Fire an event named negotiationneeded at connection.
+ ErrorResult rv;
+ mPCObserver->FireNegotiationNeededEvent(rv);
+ }));
+}
+
+void PeerConnectionImpl::NotifyDataChannel(
+ already_AddRefed<DataChannel> aChannel) {
+ PC_AUTO_ENTER_API_CALL_NO_CHECK();
+
+ RefPtr<DataChannel> channel(aChannel);
+ MOZ_ASSERT(channel);
+ CSFLogDebug(LOGTAG, "%s: channel: %p", __FUNCTION__, channel.get());
+
+ RefPtr<nsDOMDataChannel> domchannel;
+ nsresult rv = NS_NewDOMDataChannel(channel.forget(), mWindow,
+ getter_AddRefs(domchannel));
+ NS_ENSURE_SUCCESS_VOID(rv);
+
+ JSErrorResult jrv;
+ mPCObserver->NotifyDataChannel(*domchannel, jrv);
+}
+
+void PeerConnectionImpl::NotifyDataChannelOpen(DataChannel*) {
+ mDataChannelsOpened++;
+}
+
+void PeerConnectionImpl::NotifyDataChannelClosed(DataChannel*) {
+ mDataChannelsClosed++;
+}
+
+void PeerConnectionImpl::NotifySctpConnected() {
+ if (!mSctpTransport) {
+ MOZ_ASSERT(false);
+ return;
+ }
+
+ mSctpTransport->UpdateState(RTCSctpTransportState::Connected);
+}
+
+void PeerConnectionImpl::NotifySctpClosed() {
+ if (!mSctpTransport) {
+ MOZ_ASSERT(false);
+ return;
+ }
+
+ mSctpTransport->UpdateState(RTCSctpTransportState::Closed);
+}
+
+NS_IMETHODIMP
+PeerConnectionImpl::CreateOffer(const RTCOfferOptions& aOptions) {
+ JsepOfferOptions options;
+ // convert the RTCOfferOptions to JsepOfferOptions
+ if (aOptions.mOfferToReceiveAudio.WasPassed()) {
+ options.mOfferToReceiveAudio =
+ mozilla::Some(size_t(aOptions.mOfferToReceiveAudio.Value()));
+ }
+
+ if (aOptions.mOfferToReceiveVideo.WasPassed()) {
+ options.mOfferToReceiveVideo =
+ mozilla::Some(size_t(aOptions.mOfferToReceiveVideo.Value()));
+ }
+
+ options.mIceRestart = mozilla::Some(aOptions.mIceRestart ||
+ !mLocalIceCredentialsToReplace.empty());
+
+ return CreateOffer(options);
+}
+
+static void DeferredCreateOffer(const std::string& aPcHandle,
+ const JsepOfferOptions& aOptions) {
+ PeerConnectionWrapper wrapper(aPcHandle);
+
+ if (wrapper.impl()) {
+ if (!PeerConnectionCtx::GetInstance()->isReady()) {
+ MOZ_CRASH(
+ "Why is DeferredCreateOffer being executed when the "
+ "PeerConnectionCtx isn't ready?");
+ }
+ wrapper.impl()->CreateOffer(aOptions);
+ }
+}
+
+// Have to use unique_ptr because webidl enums are generated without a
+// copy c'tor.
+static std::unique_ptr<dom::PCErrorData> buildJSErrorData(
+ const JsepSession::Result& aResult, const std::string& aMessage) {
+ std::unique_ptr<dom::PCErrorData> result(new dom::PCErrorData);
+ result->mName = *aResult.mError;
+ result->mMessage = NS_ConvertASCIItoUTF16(aMessage.c_str());
+ return result;
+}
+
+// Used by unit tests and the IDL CreateOffer.
+NS_IMETHODIMP
+PeerConnectionImpl::CreateOffer(const JsepOfferOptions& aOptions) {
+ PC_AUTO_ENTER_API_CALL(true);
+
+ if (!PeerConnectionCtx::GetInstance()->isReady()) {
+ // Uh oh. We're not ready yet. Enqueue this operation.
+ PeerConnectionCtx::GetInstance()->queueJSEPOperation(
+ WrapRunnableNM(DeferredCreateOffer, mHandle, aOptions));
+ STAMP_TIMECARD(mTimeCard, "Deferring CreateOffer (not ready)");
+ return NS_OK;
+ }
+
+ CSFLogDebug(LOGTAG, "CreateOffer()");
+
+ nsresult nrv = ConfigureJsepSessionCodecs();
+ if (NS_FAILED(nrv)) {
+ CSFLogError(LOGTAG, "Failed to configure codecs");
+ return nrv;
+ }
+
+ STAMP_TIMECARD(mTimeCard, "Create Offer");
+
+ GetMainThreadSerialEventTarget()->Dispatch(NS_NewRunnableFunction(
+ __func__, [this, self = RefPtr<PeerConnectionImpl>(this), aOptions] {
+ std::string offer;
+
+ SyncToJsep();
+ UniquePtr<JsepSession> uncommittedJsepSession(mJsepSession->Clone());
+ JsepSession::Result result =
+ uncommittedJsepSession->CreateOffer(aOptions, &offer);
+ JSErrorResult rv;
+ if (result.mError.isSome()) {
+ std::string errorString = uncommittedJsepSession->GetLastError();
+
+ CSFLogError(LOGTAG, "%s: pc = %s, error = %s", __FUNCTION__,
+ mHandle.c_str(), errorString.c_str());
+
+ mPCObserver->OnCreateOfferError(
+ *buildJSErrorData(result, errorString), rv);
+ } else {
+ mJsepSession = std::move(uncommittedJsepSession);
+ mPCObserver->OnCreateOfferSuccess(ObString(offer.c_str()), rv);
+ }
+ }));
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+PeerConnectionImpl::CreateAnswer() {
+ PC_AUTO_ENTER_API_CALL(true);
+
+ CSFLogDebug(LOGTAG, "CreateAnswer()");
+
+ STAMP_TIMECARD(mTimeCard, "Create Answer");
+ // TODO(bug 1098015): Once RTCAnswerOptions is standardized, we'll need to
+ // add it as a param to CreateAnswer, and convert it here.
+ JsepAnswerOptions options;
+
+ GetMainThreadSerialEventTarget()->Dispatch(NS_NewRunnableFunction(
+ __func__, [this, self = RefPtr<PeerConnectionImpl>(this), options] {
+ std::string answer;
+ SyncToJsep();
+ UniquePtr<JsepSession> uncommittedJsepSession(mJsepSession->Clone());
+ JsepSession::Result result =
+ uncommittedJsepSession->CreateAnswer(options, &answer);
+ JSErrorResult rv;
+ if (result.mError.isSome()) {
+ std::string errorString = uncommittedJsepSession->GetLastError();
+
+ CSFLogError(LOGTAG, "%s: pc = %s, error = %s", __FUNCTION__,
+ mHandle.c_str(), errorString.c_str());
+
+ mPCObserver->OnCreateAnswerError(
+ *buildJSErrorData(result, errorString), rv);
+ } else {
+ mJsepSession = std::move(uncommittedJsepSession);
+ mPCObserver->OnCreateAnswerSuccess(ObString(answer.c_str()), rv);
+ }
+ }));
+
+ return NS_OK;
+}
+
+dom::RTCSdpType ToDomSdpType(JsepSdpType aType) {
+ switch (aType) {
+ case kJsepSdpOffer:
+ return dom::RTCSdpType::Offer;
+ case kJsepSdpAnswer:
+ return dom::RTCSdpType::Answer;
+ case kJsepSdpPranswer:
+ return dom::RTCSdpType::Pranswer;
+ case kJsepSdpRollback:
+ return dom::RTCSdpType::Rollback;
+ }
+
+ MOZ_CRASH("Nonexistent JsepSdpType");
+}
+
+JsepSdpType ToJsepSdpType(dom::RTCSdpType aType) {
+ switch (aType) {
+ case dom::RTCSdpType::Offer:
+ return kJsepSdpOffer;
+ case dom::RTCSdpType::Pranswer:
+ return kJsepSdpPranswer;
+ case dom::RTCSdpType::Answer:
+ return kJsepSdpAnswer;
+ case dom::RTCSdpType::Rollback:
+ return kJsepSdpRollback;
+ case dom::RTCSdpType::EndGuard_:;
+ }
+
+ MOZ_CRASH("Nonexistent dom::RTCSdpType");
+}
+
+NS_IMETHODIMP
+PeerConnectionImpl::SetLocalDescription(int32_t aAction, const char* aSDP) {
+ PC_AUTO_ENTER_API_CALL(true);
+
+ if (!aSDP) {
+ CSFLogError(LOGTAG, "%s - aSDP is NULL", __FUNCTION__);
+ return NS_ERROR_FAILURE;
+ }
+
+ STAMP_TIMECARD(mTimeCard, "Set Local Description");
+
+ if (AnyLocalTrackHasPeerIdentity()) {
+ mRequestedPrivacy = Some(PrincipalPrivacy::Private);
+ }
+
+ mozilla::dom::RTCSdpHistoryEntryInternal sdpEntry;
+ sdpEntry.mIsLocal = true;
+ sdpEntry.mTimestamp = mTimestampMaker.GetNow().ToDom();
+ sdpEntry.mSdp = NS_ConvertASCIItoUTF16(aSDP);
+ auto appendHistory = [&]() {
+ if (!mSdpHistory.AppendElement(sdpEntry, fallible)) {
+ mozalloc_handle_oom(0);
+ }
+ };
+
+ mLocalRequestedSDP = aSDP;
+
+ SyncToJsep();
+
+ bool wasRestartingIce = mJsepSession->IsIceRestarting();
+ JsepSdpType sdpType;
+ switch (aAction) {
+ case IPeerConnection::kActionOffer:
+ sdpType = mozilla::kJsepSdpOffer;
+ break;
+ case IPeerConnection::kActionAnswer:
+ sdpType = mozilla::kJsepSdpAnswer;
+ break;
+ case IPeerConnection::kActionPRAnswer:
+ sdpType = mozilla::kJsepSdpPranswer;
+ break;
+ case IPeerConnection::kActionRollback:
+ sdpType = mozilla::kJsepSdpRollback;
+ break;
+ default:
+ MOZ_ASSERT(false);
+ appendHistory();
+ return NS_ERROR_FAILURE;
+ }
+ MOZ_ASSERT(!mUncommittedJsepSession);
+ mUncommittedJsepSession.reset(mJsepSession->Clone());
+ JsepSession::Result result =
+ mUncommittedJsepSession->SetLocalDescription(sdpType, mLocalRequestedSDP);
+ JSErrorResult rv;
+ if (result.mError.isSome()) {
+ std::string errorString = mUncommittedJsepSession->GetLastError();
+ mUncommittedJsepSession = nullptr;
+ CSFLogError(LOGTAG, "%s: pc = %s, error = %s", __FUNCTION__,
+ mHandle.c_str(), errorString.c_str());
+ mPCObserver->OnSetDescriptionError(*buildJSErrorData(result, errorString),
+ rv);
+ sdpEntry.mErrors = GetLastSdpParsingErrors();
+ } else {
+ if (wasRestartingIce) {
+ RecordIceRestartStatistics(sdpType);
+ }
+
+ mPCObserver->OnSetDescriptionSuccess(rv);
+ }
+
+ appendHistory();
+
+ if (rv.Failed()) {
+ return rv.StealNSResult();
+ }
+
+ return NS_OK;
+}
+
+static void DeferredSetRemote(const std::string& aPcHandle, int32_t aAction,
+ const std::string& aSdp) {
+ PeerConnectionWrapper wrapper(aPcHandle);
+
+ if (wrapper.impl()) {
+ if (!PeerConnectionCtx::GetInstance()->isReady()) {
+ MOZ_CRASH(
+ "Why is DeferredSetRemote being executed when the "
+ "PeerConnectionCtx isn't ready?");
+ }
+ wrapper.impl()->SetRemoteDescription(aAction, aSdp.c_str());
+ }
+}
+
+NS_IMETHODIMP
+PeerConnectionImpl::SetRemoteDescription(int32_t action, const char* aSDP) {
+ PC_AUTO_ENTER_API_CALL(true);
+
+ if (!aSDP) {
+ CSFLogError(LOGTAG, "%s - aSDP is NULL", __FUNCTION__);
+ return NS_ERROR_FAILURE;
+ }
+
+ if (action == IPeerConnection::kActionOffer) {
+ if (!PeerConnectionCtx::GetInstance()->isReady()) {
+ // Uh oh. We're not ready yet. Enqueue this operation. (This must be a
+ // remote offer, or else we would not have gotten this far)
+ PeerConnectionCtx::GetInstance()->queueJSEPOperation(WrapRunnableNM(
+ DeferredSetRemote, mHandle, action, std::string(aSDP)));
+ STAMP_TIMECARD(mTimeCard, "Deferring SetRemote (not ready)");
+ return NS_OK;
+ }
+
+ nsresult nrv = ConfigureJsepSessionCodecs();
+ if (NS_FAILED(nrv)) {
+ CSFLogError(LOGTAG, "Failed to configure codecs");
+ return nrv;
+ }
+ }
+
+ STAMP_TIMECARD(mTimeCard, "Set Remote Description");
+
+ mozilla::dom::RTCSdpHistoryEntryInternal sdpEntry;
+ sdpEntry.mIsLocal = false;
+ sdpEntry.mTimestamp = mTimestampMaker.GetNow().ToDom();
+ sdpEntry.mSdp = NS_ConvertASCIItoUTF16(aSDP);
+ auto appendHistory = [&]() {
+ if (!mSdpHistory.AppendElement(sdpEntry, fallible)) {
+ mozalloc_handle_oom(0);
+ }
+ };
+
+ SyncToJsep();
+
+ mRemoteRequestedSDP = aSDP;
+ bool wasRestartingIce = mJsepSession->IsIceRestarting();
+ JsepSdpType sdpType;
+ switch (action) {
+ case IPeerConnection::kActionOffer:
+ sdpType = mozilla::kJsepSdpOffer;
+ break;
+ case IPeerConnection::kActionAnswer:
+ sdpType = mozilla::kJsepSdpAnswer;
+ break;
+ case IPeerConnection::kActionPRAnswer:
+ sdpType = mozilla::kJsepSdpPranswer;
+ break;
+ case IPeerConnection::kActionRollback:
+ sdpType = mozilla::kJsepSdpRollback;
+ break;
+ default:
+ MOZ_ASSERT(false);
+ return NS_ERROR_FAILURE;
+ }
+
+ MOZ_ASSERT(!mUncommittedJsepSession);
+ mUncommittedJsepSession.reset(mJsepSession->Clone());
+ JsepSession::Result result = mUncommittedJsepSession->SetRemoteDescription(
+ sdpType, mRemoteRequestedSDP);
+ JSErrorResult jrv;
+ if (result.mError.isSome()) {
+ std::string errorString = mUncommittedJsepSession->GetLastError();
+ mUncommittedJsepSession = nullptr;
+ sdpEntry.mErrors = GetLastSdpParsingErrors();
+ CSFLogError(LOGTAG, "%s: pc = %s, error = %s", __FUNCTION__,
+ mHandle.c_str(), errorString.c_str());
+ mPCObserver->OnSetDescriptionError(*buildJSErrorData(result, errorString),
+ jrv);
+ } else {
+ if (wasRestartingIce) {
+ RecordIceRestartStatistics(sdpType);
+ }
+
+ mPCObserver->OnSetDescriptionSuccess(jrv);
+ }
+
+ appendHistory();
+
+ if (jrv.Failed()) {
+ return jrv.StealNSResult();
+ }
+
+ return NS_OK;
+}
+
+already_AddRefed<dom::Promise> PeerConnectionImpl::GetStats(
+ MediaStreamTrack* aSelector) {
+ if (!mWindow) {
+ MOZ_CRASH("Cannot create a promise without a window!");
+ }
+
+ nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(mWindow);
+ ErrorResult rv;
+ RefPtr<Promise> promise = Promise::Create(global, rv);
+ if (NS_WARN_IF(rv.Failed())) {
+ MOZ_CRASH("Failed to create a promise!");
+ }
+
+ if (!IsClosed()) {
+ GetStats(aSelector, false)
+ ->Then(
+ GetMainThreadSerialEventTarget(), __func__,
+ [promise, window = mWindow](
+ UniquePtr<dom::RTCStatsReportInternal>&& aReport) {
+ RefPtr<RTCStatsReport> report(new RTCStatsReport(window));
+ report->Incorporate(*aReport);
+ promise->MaybeResolve(std::move(report));
+ },
+ [promise, window = mWindow](nsresult aError) {
+ RefPtr<RTCStatsReport> report(new RTCStatsReport(window));
+ promise->MaybeResolve(std::move(report));
+ });
+ } else {
+ promise->MaybeReject(NS_ERROR_DOM_INVALID_STATE_ERR);
+ }
+
+ return promise.forget();
+}
+
+void PeerConnectionImpl::GetRemoteStreams(
+ nsTArray<RefPtr<DOMMediaStream>>& aStreamsOut) const {
+ aStreamsOut = mReceiveStreams.Clone();
+}
+
+NS_IMETHODIMP
+PeerConnectionImpl::AddIceCandidate(
+ const char* aCandidate, const char* aMid, const char* aUfrag,
+ const dom::Nullable<unsigned short>& aLevel) {
+ PC_AUTO_ENTER_API_CALL(true);
+
+ if (mForceIceTcp &&
+ std::string::npos != std::string(aCandidate).find(" UDP ")) {
+ CSFLogError(LOGTAG, "Blocking remote UDP candidate: %s", aCandidate);
+ return NS_OK;
+ }
+
+ STAMP_TIMECARD(mTimeCard, "Add Ice Candidate");
+
+ CSFLogDebug(LOGTAG, "AddIceCandidate: %s %s", aCandidate, aUfrag);
+
+ std::string transportId;
+ Maybe<unsigned short> level;
+ if (!aLevel.IsNull()) {
+ level = Some(aLevel.Value());
+ }
+ MOZ_DIAGNOSTIC_ASSERT(
+ !mUncommittedJsepSession,
+ "AddIceCandidate is chained, which means it should never "
+ "run while an sRD/sLD is in progress");
+ JsepSession::Result result = mJsepSession->AddRemoteIceCandidate(
+ aCandidate, aMid, level, aUfrag, &transportId);
+
+ if (!result.mError.isSome()) {
+ // We do not bother the MediaTransportHandler about this before
+ // offer/answer concludes. Once offer/answer concludes, we will extract
+ // these candidates from the remote SDP.
+ if (mSignalingState == RTCSignalingState::Stable && !transportId.empty()) {
+ AddIceCandidate(aCandidate, transportId, aUfrag);
+ mRawTrickledCandidates.push_back(aCandidate);
+ }
+ // Spec says we queue a task for these updates
+ GetMainThreadSerialEventTarget()->Dispatch(NS_NewRunnableFunction(
+ __func__, [this, self = RefPtr<PeerConnectionImpl>(this)] {
+ if (IsClosed()) {
+ return;
+ }
+ mPendingRemoteDescription =
+ mJsepSession->GetRemoteDescription(kJsepDescriptionPending);
+ mCurrentRemoteDescription =
+ mJsepSession->GetRemoteDescription(kJsepDescriptionCurrent);
+ JSErrorResult rv;
+ mPCObserver->OnAddIceCandidateSuccess(rv);
+ }));
+ } else {
+ std::string errorString = mJsepSession->GetLastError();
+
+ CSFLogError(LOGTAG,
+ "Failed to incorporate remote candidate into SDP:"
+ " res = %u, candidate = %s, level = %i, error = %s",
+ static_cast<unsigned>(*result.mError), aCandidate,
+ level.valueOr(-1), errorString.c_str());
+
+ GetMainThreadSerialEventTarget()->Dispatch(NS_NewRunnableFunction(
+ __func__,
+ [this, self = RefPtr<PeerConnectionImpl>(this), errorString, result] {
+ if (IsClosed()) {
+ return;
+ }
+ JSErrorResult rv;
+ mPCObserver->OnAddIceCandidateError(
+ *buildJSErrorData(result, errorString), rv);
+ }));
+ }
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+PeerConnectionImpl::CloseStreams() {
+ PC_AUTO_ENTER_API_CALL(false);
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+PeerConnectionImpl::SetPeerIdentity(const nsAString& aPeerIdentity) {
+ PC_AUTO_ENTER_API_CALL(true);
+ MOZ_ASSERT(!aPeerIdentity.IsEmpty());
+
+ // once set, this can't be changed
+ if (mPeerIdentity) {
+ if (!mPeerIdentity->Equals(aPeerIdentity)) {
+ return NS_ERROR_FAILURE;
+ }
+ } else {
+ mPeerIdentity = new PeerIdentity(aPeerIdentity);
+ Document* doc = mWindow->GetExtantDoc();
+ if (!doc) {
+ CSFLogInfo(LOGTAG, "Can't update principal on streams; document gone");
+ return NS_ERROR_FAILURE;
+ }
+ for (const auto& transceiver : mTransceivers) {
+ transceiver->Sender()->GetPipeline()->UpdateSinkIdentity(
+ doc->NodePrincipal(), mPeerIdentity);
+ }
+ }
+ return NS_OK;
+}
+
+nsresult PeerConnectionImpl::OnAlpnNegotiated(bool aPrivacyRequested) {
+ PC_AUTO_ENTER_API_CALL(false);
+ MOZ_DIAGNOSTIC_ASSERT(!mRequestedPrivacy ||
+ (*mRequestedPrivacy == PrincipalPrivacy::Private) ==
+ aPrivacyRequested);
+
+ mRequestedPrivacy = Some(aPrivacyRequested ? PrincipalPrivacy::Private
+ : PrincipalPrivacy::NonPrivate);
+ // This updates the MediaPipelines with a private PrincipalHandle. Note that
+ // MediaPipelineReceive has its own AlpnNegotiated handler so it can get
+ // signaled off-main to drop data until it receives the new PrincipalHandle
+ // from us.
+ UpdateMediaPipelines();
+ return NS_OK;
+}
+
+void PeerConnectionImpl::OnDtlsStateChange(const std::string& aTransportId,
+ TransportLayer::State aState) {
+ auto it = mTransportIdToRTCDtlsTransport.find(aTransportId);
+ if (it != mTransportIdToRTCDtlsTransport.end()) {
+ it->second->UpdateState(aState);
+ }
+ // Whenever the state of an RTCDtlsTransport changes or when the [[IsClosed]]
+ // slot turns true, the user agent MUST update the connection state by
+ // queueing a task that runs the following steps:
+ // NOTE: The business about [[IsClosed]] here is probably a bug, because the
+ // rest of the spec makes it very clear that events should never fire when
+ // [[IsClosed]] is true. See https://github.com/w3c/webrtc-pc/issues/2865
+ GetMainThreadSerialEventTarget()->Dispatch(NS_NewRunnableFunction(
+ __func__, [this, self = RefPtr<PeerConnectionImpl>(this)] {
+ // Let connection be this RTCPeerConnection object.
+ // Let newState be the value of deriving a new state value as described
+ // by the RTCPeerConnectionState enum.
+ // If connection.[[ConnectionState]] is equal to newState, abort these
+ // steps.
+ // Set connection.[[ConnectionState]] to newState.
+ if (UpdateConnectionState()) {
+ // Fire an event named connectionstatechange at connection.
+ JSErrorResult jrv;
+ mPCObserver->OnStateChange(PCObserverStateType::ConnectionState, jrv);
+ }
+ }));
+}
+
+RTCPeerConnectionState PeerConnectionImpl::GetNewConnectionState() const {
+ // closed The RTCPeerConnection object's [[IsClosed]] slot is true.
+ if (IsClosed()) {
+ return RTCPeerConnectionState::Closed;
+ }
+
+ // Would use a bitset, but that requires lots of static_cast<size_t>
+ // Oh well.
+ std::set<RTCDtlsTransportState> statesFound;
+ for (const auto& [id, dtlsTransport] : mTransportIdToRTCDtlsTransport) {
+ Unused << id;
+ statesFound.insert(dtlsTransport->State());
+ }
+
+ // failed The previous state doesn't apply, and either
+ // [[IceConnectionState]] is "failed" or any RTCDtlsTransports are in the
+ // "failed" state.
+ if (mIceConnectionState == RTCIceConnectionState::Failed ||
+ statesFound.count(RTCDtlsTransportState::Failed)) {
+ return RTCPeerConnectionState::Failed;
+ }
+
+ // disconnected None of the previous states apply, and
+ // [[IceConnectionState]] is "disconnected".
+ if (mIceConnectionState == RTCIceConnectionState::Disconnected) {
+ return RTCPeerConnectionState::Disconnected;
+ }
+
+ // new None of the previous states apply, and either
+ // [[IceConnectionState]] is "new", and all RTCDtlsTransports are in the
+ // "new" or "closed" state...
+ if (mIceConnectionState == RTCIceConnectionState::New &&
+ !statesFound.count(RTCDtlsTransportState::Connecting) &&
+ !statesFound.count(RTCDtlsTransportState::Connected) &&
+ !statesFound.count(RTCDtlsTransportState::Failed)) {
+ return RTCPeerConnectionState::New;
+ }
+
+ // ...or there are no transports.
+ if (statesFound.empty()) {
+ return RTCPeerConnectionState::New;
+ }
+
+ // connected None of the previous states apply,
+ // [[IceConnectionState]] is "connected", and all RTCDtlsTransports are in
+ // the "connected" or "closed" state.
+ if (mIceConnectionState == RTCIceConnectionState::Connected &&
+ !statesFound.count(RTCDtlsTransportState::New) &&
+ !statesFound.count(RTCDtlsTransportState::Failed) &&
+ !statesFound.count(RTCDtlsTransportState::Connecting)) {
+ return RTCPeerConnectionState::Connected;
+ }
+
+ // connecting None of the previous states apply.
+ return RTCPeerConnectionState::Connecting;
+}
+
+bool PeerConnectionImpl::UpdateConnectionState() {
+ auto newState = GetNewConnectionState();
+ if (newState != mConnectionState) {
+ CSFLogDebug(LOGTAG, "%s: %d -> %d (%p)", __FUNCTION__,
+ static_cast<int>(mConnectionState), static_cast<int>(newState),
+ this);
+ mConnectionState = newState;
+ if (mConnectionState != RTCPeerConnectionState::Closed) {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+void PeerConnectionImpl::OnMediaError(const std::string& aError) {
+ CSFLogError(LOGTAG, "Encountered media error! %s", aError.c_str());
+ // TODO: Let content know about this somehow.
+}
+
+void PeerConnectionImpl::DumpPacket_m(size_t level, dom::mozPacketDumpType type,
+ bool sending,
+ UniquePtr<uint8_t[]>& packet,
+ size_t size) {
+ if (IsClosed()) {
+ return;
+ }
+
+ // TODO: Is this efficient? Should we try grabbing our JS ctx from somewhere
+ // else?
+ AutoJSAPI jsapi;
+ if (!jsapi.Init(mWindow)) {
+ return;
+ }
+
+ UniquePtr<void, JS::FreePolicy> packetPtr{packet.release()};
+ JS::Rooted<JSObject*> jsobj(
+ jsapi.cx(),
+ JS::NewArrayBufferWithContents(jsapi.cx(), size, std::move(packetPtr)));
+
+ RootedSpiderMonkeyInterface<ArrayBuffer> arrayBuffer(jsapi.cx());
+ if (!arrayBuffer.Init(jsobj)) {
+ return;
+ }
+
+ JSErrorResult jrv;
+ mPCObserver->OnPacket(level, type, sending, arrayBuffer, jrv);
+}
+
+bool PeerConnectionImpl::HostnameInPref(const char* aPref,
+ const nsCString& aHostName) {
+ auto HostInDomain = [](const nsCString& aHost, const nsCString& aPattern) {
+ int32_t patternOffset = 0;
+ int32_t hostOffset = 0;
+
+ // Act on '*.' wildcard in the left-most position in a domain pattern.
+ if (StringBeginsWith(aPattern, nsCString("*."))) {
+ patternOffset = 2;
+
+ // Ignore the lowest level sub-domain for the hostname.
+ hostOffset = aHost.FindChar('.') + 1;
+
+ if (hostOffset <= 1) {
+ // Reject a match between a wildcard and a TLD or '.foo' form.
+ return false;
+ }
+ }
+
+ nsDependentCString hostRoot(aHost, hostOffset);
+ return hostRoot.EqualsIgnoreCase(aPattern.BeginReading() + patternOffset);
+ };
+
+ nsCString domainList;
+ nsresult nr = Preferences::GetCString(aPref, domainList);
+
+ if (NS_FAILED(nr)) {
+ return false;
+ }
+
+ domainList.StripWhitespace();
+
+ if (domainList.IsEmpty() || aHostName.IsEmpty()) {
+ return false;
+ }
+
+ // Get UTF8 to ASCII domain name normalization service
+ nsresult rv;
+ nsCOMPtr<nsIIDNService> idnService =
+ do_GetService("@mozilla.org/network/idn-service;1", &rv);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return false;
+ }
+
+ // Test each domain name in the comma separated list
+ // after converting from UTF8 to ASCII. Each domain
+ // must match exactly or have a single leading '*.' wildcard.
+ for (const nsACString& each : domainList.Split(',')) {
+ nsCString domainPattern;
+ rv = idnService->ConvertUTF8toACE(each, domainPattern);
+ if (NS_SUCCEEDED(rv)) {
+ if (HostInDomain(aHostName, domainPattern)) {
+ return true;
+ }
+ } else {
+ NS_WARNING("Failed to convert UTF-8 host to ASCII");
+ }
+ }
+
+ return false;
+}
+
+nsresult PeerConnectionImpl::EnablePacketDump(unsigned long level,
+ dom::mozPacketDumpType type,
+ bool sending) {
+ return GetPacketDumper()->EnablePacketDump(level, type, sending);
+}
+
+nsresult PeerConnectionImpl::DisablePacketDump(unsigned long level,
+ dom::mozPacketDumpType type,
+ bool sending) {
+ return GetPacketDumper()->DisablePacketDump(level, type, sending);
+}
+
+void PeerConnectionImpl::StampTimecard(const char* aEvent) {
+ MOZ_ASSERT(NS_IsMainThread());
+ STAMP_TIMECARD(mTimeCard, aEvent);
+}
+
+void PeerConnectionImpl::SendWarningToConsole(const nsCString& aWarning) {
+ nsAutoString msg = NS_ConvertASCIItoUTF16(aWarning);
+ nsContentUtils::ReportToConsoleByWindowID(msg, nsIScriptError::warningFlag,
+ "WebRTC"_ns, mWindow->WindowID());
+}
+
+void PeerConnectionImpl::GetDefaultVideoCodecs(
+ std::vector<UniquePtr<JsepCodecDescription>>& aSupportedCodecs,
+ bool aUseRtx) {
+ // Supported video codecs.
+ // Note: order here implies priority for building offers!
+ aSupportedCodecs.emplace_back(
+ JsepVideoCodecDescription::CreateDefaultVP8(aUseRtx));
+ aSupportedCodecs.emplace_back(
+ JsepVideoCodecDescription::CreateDefaultVP9(aUseRtx));
+ aSupportedCodecs.emplace_back(
+ JsepVideoCodecDescription::CreateDefaultH264_1(aUseRtx));
+ aSupportedCodecs.emplace_back(
+ JsepVideoCodecDescription::CreateDefaultH264_0(aUseRtx));
+ aSupportedCodecs.emplace_back(
+ JsepVideoCodecDescription::CreateDefaultUlpFec());
+ aSupportedCodecs.emplace_back(
+ JsepApplicationCodecDescription::CreateDefault());
+ aSupportedCodecs.emplace_back(JsepVideoCodecDescription::CreateDefaultRed());
+}
+
+void PeerConnectionImpl::GetDefaultAudioCodecs(
+ std::vector<UniquePtr<JsepCodecDescription>>& aSupportedCodecs) {
+ aSupportedCodecs.emplace_back(JsepAudioCodecDescription::CreateDefaultOpus());
+ aSupportedCodecs.emplace_back(JsepAudioCodecDescription::CreateDefaultG722());
+ aSupportedCodecs.emplace_back(JsepAudioCodecDescription::CreateDefaultPCMU());
+ aSupportedCodecs.emplace_back(JsepAudioCodecDescription::CreateDefaultPCMA());
+ aSupportedCodecs.emplace_back(
+ JsepAudioCodecDescription::CreateDefaultTelephoneEvent());
+}
+
+void PeerConnectionImpl::GetDefaultRtpExtensions(
+ std::vector<RtpExtensionHeader>& aRtpExtensions) {
+ RtpExtensionHeader audioLevel = {JsepMediaType::kAudio,
+ SdpDirectionAttribute::Direction::kSendrecv,
+ webrtc::RtpExtension::kAudioLevelUri};
+ aRtpExtensions.push_back(audioLevel);
+
+ RtpExtensionHeader csrcAudioLevels = {
+ JsepMediaType::kAudio, SdpDirectionAttribute::Direction::kRecvonly,
+ webrtc::RtpExtension::kCsrcAudioLevelsUri};
+ aRtpExtensions.push_back(csrcAudioLevels);
+
+ RtpExtensionHeader mid = {JsepMediaType::kAudioVideo,
+ SdpDirectionAttribute::Direction::kSendrecv,
+ webrtc::RtpExtension::kMidUri};
+ aRtpExtensions.push_back(mid);
+
+ RtpExtensionHeader absSendTime = {JsepMediaType::kVideo,
+ SdpDirectionAttribute::Direction::kSendrecv,
+ webrtc::RtpExtension::kAbsSendTimeUri};
+ aRtpExtensions.push_back(absSendTime);
+
+ RtpExtensionHeader timestampOffset = {
+ JsepMediaType::kVideo, SdpDirectionAttribute::Direction::kSendrecv,
+ webrtc::RtpExtension::kTimestampOffsetUri};
+ aRtpExtensions.push_back(timestampOffset);
+
+ RtpExtensionHeader playoutDelay = {
+ JsepMediaType::kVideo, SdpDirectionAttribute::Direction::kRecvonly,
+ webrtc::RtpExtension::kPlayoutDelayUri};
+ aRtpExtensions.push_back(playoutDelay);
+
+ RtpExtensionHeader transportSequenceNumber = {
+ JsepMediaType::kVideo, SdpDirectionAttribute::Direction::kSendrecv,
+ webrtc::RtpExtension::kTransportSequenceNumberUri};
+ aRtpExtensions.push_back(transportSequenceNumber);
+}
+
+void PeerConnectionImpl::GetCapabilities(
+ const nsAString& aKind, dom::Nullable<dom::RTCRtpCapabilities>& aResult,
+ sdp::Direction aDirection) {
+ std::vector<UniquePtr<JsepCodecDescription>> codecs;
+ std::vector<RtpExtensionHeader> headers;
+ auto mediaType = JsepMediaType::kNone;
+
+ if (aKind.EqualsASCII("video")) {
+ GetDefaultVideoCodecs(codecs, true);
+ mediaType = JsepMediaType::kVideo;
+ } else if (aKind.EqualsASCII("audio")) {
+ GetDefaultAudioCodecs(codecs);
+ mediaType = JsepMediaType::kAudio;
+ } else {
+ return;
+ }
+
+ GetDefaultRtpExtensions(headers);
+
+ const bool redUlpfecEnabled =
+ Preferences::GetBool("media.navigator.video.red_ulpfec_enabled", false);
+
+ // Use the codecs for kind to fill out the RTCRtpCodecCapability
+ for (const auto& codec : codecs) {
+ // To avoid misleading information on codec capabilities skip those
+ // not signaled for audio/video (webrtc-datachannel)
+ // and any disabled by pref (ulpfec and red).
+ if (codec->mName == "webrtc-datachannel" ||
+ (codec->mName == "ulpfec" && !redUlpfecEnabled) ||
+ (codec->mName == "red" && !redUlpfecEnabled)) {
+ continue;
+ }
+
+ dom::RTCRtpCodecCapability capability;
+ capability.mMimeType = aKind + NS_ConvertASCIItoUTF16("/" + codec->mName);
+ capability.mClockRate = codec->mClock;
+
+ if (codec->mChannels) {
+ capability.mChannels.Construct(codec->mChannels);
+ }
+
+ UniquePtr<SdpFmtpAttributeList::Parameters> params;
+ codec->ApplyConfigToFmtp(params);
+
+ if (params != nullptr) {
+ std::ostringstream paramsString;
+ params->Serialize(paramsString);
+ nsTString<char16_t> fmtp;
+ fmtp.AssignASCII(paramsString.str());
+ capability.mSdpFmtpLine.Construct(fmtp);
+ }
+
+ if (!aResult.SetValue().mCodecs.AppendElement(capability, fallible)) {
+ mozalloc_handle_oom(0);
+ }
+ }
+
+ // We need to manually add rtx for video.
+ if (mediaType == JsepMediaType::kVideo) {
+ dom::RTCRtpCodecCapability capability;
+ capability.mMimeType = aKind + NS_ConvertASCIItoUTF16("/rtx");
+ capability.mClockRate = 90000;
+ if (!aResult.SetValue().mCodecs.AppendElement(capability, fallible)) {
+ mozalloc_handle_oom(0);
+ }
+ }
+
+ // Add headers that match the direction and media type requested.
+ for (const auto& header : headers) {
+ if ((header.direction & aDirection) && (header.mMediaType & mediaType)) {
+ dom::RTCRtpHeaderExtensionCapability rtpHeader;
+ rtpHeader.mUri.AssignASCII(header.extensionname);
+ if (!aResult.SetValue().mHeaderExtensions.AppendElement(rtpHeader,
+ fallible)) {
+ mozalloc_handle_oom(0);
+ }
+ }
+ }
+}
+
+void PeerConnectionImpl::SetupPreferredCodecs(
+ std::vector<UniquePtr<JsepCodecDescription>>& aPreferredCodecs) {
+ bool useRtx =
+ Preferences::GetBool("media.peerconnection.video.use_rtx", false);
+
+ GetDefaultVideoCodecs(aPreferredCodecs, useRtx);
+ GetDefaultAudioCodecs(aPreferredCodecs);
+}
+
+void PeerConnectionImpl::SetupPreferredRtpExtensions(
+ std::vector<RtpExtensionHeader>& aPreferredheaders) {
+ GetDefaultRtpExtensions(aPreferredheaders);
+
+ if (!Preferences::GetBool("media.navigator.video.use_transport_cc", false)) {
+ aPreferredheaders.erase(
+ std::remove_if(
+ aPreferredheaders.begin(), aPreferredheaders.end(),
+ [&](const RtpExtensionHeader& header) {
+ return header.extensionname ==
+ webrtc::RtpExtension::kTransportSequenceNumberUri;
+ }),
+ aPreferredheaders.end());
+ }
+}
+
+nsresult PeerConnectionImpl::CalculateFingerprint(
+ const nsACString& algorithm, std::vector<uint8_t>* fingerprint) const {
+ DtlsDigest digest(algorithm);
+
+ MOZ_ASSERT(fingerprint);
+ const UniqueCERTCertificate& cert = mCertificate->Certificate();
+ nsresult rv = DtlsIdentity::ComputeFingerprint(cert, &digest);
+ if (NS_FAILED(rv)) {
+ CSFLogError(LOGTAG, "Unable to calculate certificate fingerprint, rv=%u",
+ static_cast<unsigned>(rv));
+ return rv;
+ }
+ *fingerprint = digest.value_;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+PeerConnectionImpl::GetFingerprint(char** fingerprint) {
+ MOZ_ASSERT(fingerprint);
+ MOZ_ASSERT(mCertificate);
+ std::vector<uint8_t> fp;
+ nsresult rv = CalculateFingerprint(DtlsIdentity::DEFAULT_HASH_ALGORITHM, &fp);
+ NS_ENSURE_SUCCESS(rv, rv);
+ std::ostringstream os;
+ os << DtlsIdentity::DEFAULT_HASH_ALGORITHM << ' '
+ << SdpFingerprintAttributeList::FormatFingerprint(fp);
+ std::string fpStr = os.str();
+
+ char* tmp = new char[fpStr.size() + 1];
+ std::copy(fpStr.begin(), fpStr.end(), tmp);
+ tmp[fpStr.size()] = '\0';
+
+ *fingerprint = tmp;
+ return NS_OK;
+}
+
+void PeerConnectionImpl::GetCurrentLocalDescription(nsAString& aSDP) const {
+ aSDP = NS_ConvertASCIItoUTF16(mCurrentLocalDescription.c_str());
+}
+
+void PeerConnectionImpl::GetPendingLocalDescription(nsAString& aSDP) const {
+ aSDP = NS_ConvertASCIItoUTF16(mPendingLocalDescription.c_str());
+}
+
+void PeerConnectionImpl::GetCurrentRemoteDescription(nsAString& aSDP) const {
+ aSDP = NS_ConvertASCIItoUTF16(mCurrentRemoteDescription.c_str());
+}
+
+void PeerConnectionImpl::GetPendingRemoteDescription(nsAString& aSDP) const {
+ aSDP = NS_ConvertASCIItoUTF16(mPendingRemoteDescription.c_str());
+}
+
+dom::Nullable<bool> PeerConnectionImpl::GetCurrentOfferer() const {
+ dom::Nullable<bool> result;
+ if (mCurrentOfferer.isSome()) {
+ result.SetValue(*mCurrentOfferer);
+ }
+ return result;
+}
+
+dom::Nullable<bool> PeerConnectionImpl::GetPendingOfferer() const {
+ dom::Nullable<bool> result;
+ if (mPendingOfferer.isSome()) {
+ result.SetValue(*mPendingOfferer);
+ }
+ return result;
+}
+
+NS_IMETHODIMP
+PeerConnectionImpl::SignalingState(RTCSignalingState* aState) {
+ PC_AUTO_ENTER_API_CALL_NO_CHECK();
+ MOZ_ASSERT(aState);
+
+ *aState = mSignalingState;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+PeerConnectionImpl::IceConnectionState(RTCIceConnectionState* aState) {
+ PC_AUTO_ENTER_API_CALL_NO_CHECK();
+ MOZ_ASSERT(aState);
+
+ *aState = mIceConnectionState;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+PeerConnectionImpl::IceGatheringState(RTCIceGatheringState* aState) {
+ PC_AUTO_ENTER_API_CALL_NO_CHECK();
+ MOZ_ASSERT(aState);
+
+ *aState = mIceGatheringState;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+PeerConnectionImpl::ConnectionState(RTCPeerConnectionState* aState) {
+ PC_AUTO_ENTER_API_CALL_NO_CHECK();
+ MOZ_ASSERT(aState);
+
+ *aState = mConnectionState;
+ return NS_OK;
+}
+
+nsresult PeerConnectionImpl::CheckApiState(bool assert_ice_ready) const {
+ PC_AUTO_ENTER_API_CALL_NO_CHECK();
+ MOZ_ASSERT(mTrickle || !assert_ice_ready ||
+ (mIceGatheringState == RTCIceGatheringState::Complete));
+
+ if (IsClosed()) {
+ CSFLogError(LOGTAG, "%s: called API while closed", __FUNCTION__);
+ return NS_ERROR_FAILURE;
+ }
+ return NS_OK;
+}
+
+void PeerConnectionImpl::StoreFinalStats(
+ UniquePtr<RTCStatsReportInternal>&& report) {
+ using namespace Telemetry;
+
+ report->mClosed = true;
+
+ for (const auto& inboundRtpStats : report->mInboundRtpStreamStats) {
+ bool isVideo = (inboundRtpStats.mId.Value().Find(u"video") != -1);
+ if (!isVideo) {
+ continue;
+ }
+ if (inboundRtpStats.mDiscardedPackets.WasPassed() &&
+ report->mCallDurationMs.WasPassed()) {
+ double mins = report->mCallDurationMs.Value() / (1000 * 60);
+ if (mins > 0) {
+ Accumulate(
+ WEBRTC_VIDEO_DECODER_DISCARDED_PACKETS_PER_CALL_PPM,
+ uint32_t(double(inboundRtpStats.mDiscardedPackets.Value()) / mins));
+ }
+ }
+ }
+
+ // Finally, store the stats
+ mFinalStats = std::move(report);
+}
+
+NS_IMETHODIMP
+PeerConnectionImpl::Close() {
+ CSFLogDebug(LOGTAG, "%s: for %s", __FUNCTION__, mHandle.c_str());
+ PC_AUTO_ENTER_API_CALL_NO_CHECK();
+
+ if (IsClosed()) {
+ return NS_OK;
+ }
+
+ STAMP_TIMECARD(mTimeCard, "Close");
+
+ // When ICE completes, we record some telemetry. We do this at the end of the
+ // call because we want to make sure we've waited for all trickle ICE
+ // candidates to come in; this can happen well after we've transitioned to
+ // connected. As a bonus, this allows us to detect race conditions where a
+ // stats dispatch happens right as the PC closes.
+ RecordEndOfCallTelemetry();
+
+ CSFLogInfo(LOGTAG,
+ "%s: Closing PeerConnectionImpl %s; "
+ "ending call",
+ __FUNCTION__, mHandle.c_str());
+ mRtcpReceiveListener.DisconnectIfExists();
+ if (mJsepSession) {
+ mJsepSession->Close();
+ }
+ if (mDataConnection) {
+ CSFLogInfo(LOGTAG, "%s: Destroying DataChannelConnection %p for %s",
+ __FUNCTION__, (void*)mDataConnection.get(), mHandle.c_str());
+ mDataConnection->Destroy();
+ mDataConnection =
+ nullptr; // it may not go away until the runnables are dead
+ }
+
+ if (mStunAddrsRequest) {
+ for (const auto& hostname : mRegisteredMDNSHostnames) {
+ mStunAddrsRequest->SendUnregisterMDNSHostname(
+ nsCString(hostname.c_str()));
+ }
+ mRegisteredMDNSHostnames.clear();
+ mStunAddrsRequest->Cancel();
+ mStunAddrsRequest = nullptr;
+ }
+
+ for (auto& transceiver : mTransceivers) {
+ transceiver->Close();
+ }
+
+ mTransportIdToRTCDtlsTransport.clear();
+
+ mQueuedIceCtxOperations.clear();
+
+ mOperations.Clear();
+
+ // Uncount this connection as active on the inner window upon close.
+ if (mWindow && mActiveOnWindow) {
+ mWindow->RemovePeerConnection();
+ mActiveOnWindow = false;
+ }
+
+ mSignalingState = RTCSignalingState::Closed;
+ mConnectionState = RTCPeerConnectionState::Closed;
+
+ if (!mTransportHandler) {
+ // We were never initialized, apparently.
+ return NS_OK;
+ }
+
+ // Clear any resources held by libwebrtc through our Call instance.
+ RefPtr<GenericPromise> callDestroyPromise;
+ if (mCall) {
+ // Make sure the compiler does not get confused and try to acquire a
+ // reference to this thread _after_ we null out mCall.
+ auto callThread = mCall->mCallThread;
+ callDestroyPromise =
+ InvokeAsync(callThread, __func__, [call = std::move(mCall)]() {
+ call->Destroy();
+ return GenericPromise::CreateAndResolve(
+ true, "PCImpl->WebRtcCallWrapper::Destroy");
+ });
+ } else {
+ callDestroyPromise = GenericPromise::CreateAndResolve(true, __func__);
+ }
+
+ mFinalStatsQuery =
+ GetStats(nullptr, true)
+ ->Then(
+ GetMainThreadSerialEventTarget(), __func__,
+ [this, self = RefPtr<PeerConnectionImpl>(this)](
+ UniquePtr<dom::RTCStatsReportInternal>&& aReport) mutable {
+ StoreFinalStats(std::move(aReport));
+ return GenericNonExclusivePromise::CreateAndResolve(true,
+ __func__);
+ },
+ [](nsresult aError) {
+ return GenericNonExclusivePromise::CreateAndResolve(true,
+ __func__);
+ });
+
+ // 1. Allow final stats query to complete.
+ // 2. Tear down call, if necessary. We do this before we shut down the
+ // transport handler, so RTCP BYE can be sent.
+ // 3. Unhook from the signal handler (sigslot) for transport stuff. This must
+ // be done before we tear down the transport handler.
+ // 4. Tear down the transport handler, and deregister from PeerConnectionCtx.
+ // When we deregister from PeerConnectionCtx, our final stats (if any)
+ // will be stored.
+ MOZ_RELEASE_ASSERT(mSTSThread);
+ mFinalStatsQuery
+ ->Then(GetMainThreadSerialEventTarget(), __func__,
+ [callDestroyPromise]() mutable { return callDestroyPromise; })
+ ->Then(
+ mSTSThread, __func__,
+ [signalHandler = std::move(mSignalHandler)]() mutable {
+ CSFLogDebug(
+ LOGTAG,
+ "Destroying PeerConnectionImpl::SignalHandler on STS thread");
+ return GenericPromise::CreateAndResolve(
+ true, "PeerConnectionImpl::~SignalHandler");
+ })
+ ->Then(
+ GetMainThreadSerialEventTarget(), __func__,
+ [this, self = RefPtr<PeerConnectionImpl>(this)]() mutable {
+ CSFLogDebug(LOGTAG, "PCImpl->mTransportHandler::RemoveTransports");
+ mTransportHandler->RemoveTransportsExcept(std::set<std::string>());
+ if (mPrivateWindow) {
+ mTransportHandler->ExitPrivateMode();
+ }
+ mTransportHandler = nullptr;
+ if (PeerConnectionCtx::isActive()) {
+ // If we're shutting down xpcom, this Instance will be unset
+ // before calling Close() on all remaining PCs, to avoid
+ // reentrancy.
+ PeerConnectionCtx::GetInstance()->RemovePeerConnection(mHandle);
+ }
+ });
+
+ return NS_OK;
+}
+
+void PeerConnectionImpl::BreakCycles() {
+ for (auto& transceiver : mTransceivers) {
+ transceiver->BreakCycles();
+ }
+ mTransceivers.Clear();
+}
+
+bool PeerConnectionImpl::HasPendingSetParameters() const {
+ for (const auto& transceiver : mTransceivers) {
+ if (transceiver->Sender()->HasPendingSetParameters()) {
+ return true;
+ }
+ }
+ return false;
+}
+
+void PeerConnectionImpl::InvalidateLastReturnedParameters() {
+ for (const auto& transceiver : mTransceivers) {
+ transceiver->Sender()->InvalidateLastReturnedParameters();
+ }
+}
+
+nsresult PeerConnectionImpl::SetConfiguration(
+ const RTCConfiguration& aConfiguration) {
+ nsresult rv = mTransportHandler->SetIceConfig(
+ aConfiguration.mIceServers, aConfiguration.mIceTransportPolicy);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return rv;
+ }
+
+ JsepBundlePolicy bundlePolicy;
+ switch (aConfiguration.mBundlePolicy) {
+ case dom::RTCBundlePolicy::Balanced:
+ bundlePolicy = kBundleBalanced;
+ break;
+ case dom::RTCBundlePolicy::Max_compat:
+ bundlePolicy = kBundleMaxCompat;
+ break;
+ case dom::RTCBundlePolicy::Max_bundle:
+ bundlePolicy = kBundleMaxBundle;
+ break;
+ default:
+ MOZ_CRASH();
+ }
+
+ // Ignore errors, since those ought to be handled earlier.
+ Unused << mJsepSession->SetBundlePolicy(bundlePolicy);
+
+ if (!aConfiguration.mPeerIdentity.IsEmpty()) {
+ mPeerIdentity = new PeerIdentity(aConfiguration.mPeerIdentity);
+ mRequestedPrivacy = Some(PrincipalPrivacy::Private);
+ }
+
+ auto proxyConfig = GetProxyConfig();
+ if (proxyConfig) {
+ // Note that this could check if PrivacyRequested() is set on the PC and
+ // remove "webrtc" from the ALPN list. But that would only work if the PC
+ // was constructed with a peerIdentity constraint, not when isolated
+ // streams are added. If we ever need to signal to the proxy that the
+ // media is isolated, then we would need to restructure this code.
+ mTransportHandler->SetProxyConfig(std::move(*proxyConfig));
+ }
+
+ // Store the configuration for about:webrtc
+ StoreConfigurationForAboutWebrtc(aConfiguration);
+
+ return NS_OK;
+}
+
+RTCSctpTransport* PeerConnectionImpl::GetSctp() const {
+ return mSctpTransport.get();
+}
+
+void PeerConnectionImpl::RestartIce() {
+ RestartIceNoRenegotiationNeeded();
+ // Update the negotiation-needed flag for connection.
+ UpdateNegotiationNeeded();
+}
+
+// webrtc-pc does not specify any situations where this is done, but the JSEP
+// spec does, in some situations due to setConfiguration.
+void PeerConnectionImpl::RestartIceNoRenegotiationNeeded() {
+ // Empty connection.[[LocalIceCredentialsToReplace]], and populate it with
+ // all ICE credentials (ice-ufrag and ice-pwd as defined in section 15.4 of
+ // [RFC5245]) found in connection.[[CurrentLocalDescription]], as well as all
+ // ICE credentials found in connection.[[PendingLocalDescription]].
+ mLocalIceCredentialsToReplace = mJsepSession->GetLocalIceCredentials();
+}
+
+bool PeerConnectionImpl::PluginCrash(uint32_t aPluginID,
+ const nsAString& aPluginName) {
+ // fire an event to the DOM window if this is "ours"
+ if (!AnyCodecHasPluginID(aPluginID)) {
+ return false;
+ }
+
+ CSFLogError(LOGTAG, "%s: Our plugin %llu crashed", __FUNCTION__,
+ static_cast<unsigned long long>(aPluginID));
+
+ RefPtr<Document> doc = mWindow->GetExtantDoc();
+ if (!doc) {
+ NS_WARNING("Couldn't get document for PluginCrashed event!");
+ return true;
+ }
+
+ PluginCrashedEventInit init;
+ init.mPluginID = aPluginID;
+ init.mPluginName = aPluginName;
+ init.mSubmittedCrashReport = false;
+ init.mGmpPlugin = true;
+ init.mBubbles = true;
+ init.mCancelable = true;
+
+ RefPtr<PluginCrashedEvent> event =
+ PluginCrashedEvent::Constructor(doc, u"PluginCrashed"_ns, init);
+
+ event->SetTrusted(true);
+ event->WidgetEventPtr()->mFlags.mOnlyChromeDispatch = true;
+
+ nsCOMPtr<nsPIDOMWindowInner> window = mWindow;
+ // MOZ_KnownLive due to bug 1506441
+ EventDispatcher::DispatchDOMEvent(
+ MOZ_KnownLive(nsGlobalWindowInner::Cast(window)), nullptr, event, nullptr,
+ nullptr);
+
+ return true;
+}
+
+void PeerConnectionImpl::RecordEndOfCallTelemetry() {
+ if (!mCallTelemStarted) {
+ return;
+ }
+ MOZ_RELEASE_ASSERT(!mCallTelemEnded, "Don't end telemetry twice");
+ MOZ_RELEASE_ASSERT(mJsepSession,
+ "Call telemetry only starts after jsep session start");
+ MOZ_RELEASE_ASSERT(mJsepSession->GetNegotiations() > 0,
+ "Call telemetry only starts after first connection");
+
+ // Bitmask used for WEBRTC/LOOP_CALL_TYPE telemetry reporting
+ static const uint32_t kAudioTypeMask = 1;
+ static const uint32_t kVideoTypeMask = 2;
+ static const uint32_t kDataChannelTypeMask = 4;
+
+ // Report end-of-call Telemetry
+ Telemetry::Accumulate(Telemetry::WEBRTC_RENEGOTIATIONS,
+ mJsepSession->GetNegotiations() - 1);
+ Telemetry::Accumulate(Telemetry::WEBRTC_MAX_VIDEO_SEND_TRACK,
+ mMaxSending[SdpMediaSection::MediaType::kVideo]);
+ Telemetry::Accumulate(Telemetry::WEBRTC_MAX_VIDEO_RECEIVE_TRACK,
+ mMaxReceiving[SdpMediaSection::MediaType::kVideo]);
+ Telemetry::Accumulate(Telemetry::WEBRTC_MAX_AUDIO_SEND_TRACK,
+ mMaxSending[SdpMediaSection::MediaType::kAudio]);
+ Telemetry::Accumulate(Telemetry::WEBRTC_MAX_AUDIO_RECEIVE_TRACK,
+ mMaxReceiving[SdpMediaSection::MediaType::kAudio]);
+ // DataChannels appear in both Sending and Receiving
+ Telemetry::Accumulate(Telemetry::WEBRTC_DATACHANNEL_NEGOTIATED,
+ mMaxSending[SdpMediaSection::MediaType::kApplication]);
+ // Enumerated/bitmask: 1 = Audio, 2 = Video, 4 = DataChannel
+ // A/V = 3, A/V/D = 7, etc
+ uint32_t type = 0;
+ if (mMaxSending[SdpMediaSection::MediaType::kAudio] ||
+ mMaxReceiving[SdpMediaSection::MediaType::kAudio]) {
+ type = kAudioTypeMask;
+ }
+ if (mMaxSending[SdpMediaSection::MediaType::kVideo] ||
+ mMaxReceiving[SdpMediaSection::MediaType::kVideo]) {
+ type |= kVideoTypeMask;
+ }
+ if (mMaxSending[SdpMediaSection::MediaType::kApplication]) {
+ type |= kDataChannelTypeMask;
+ }
+ Telemetry::Accumulate(Telemetry::WEBRTC_CALL_TYPE, type);
+
+ MOZ_RELEASE_ASSERT(mWindow);
+ auto found = sCallDurationTimers.find(mWindow->WindowID());
+ if (found != sCallDurationTimers.end()) {
+ found->second.UnregisterConnection((type & kAudioTypeMask) ||
+ (type & kVideoTypeMask));
+ if (found->second.IsStopped()) {
+ sCallDurationTimers.erase(found);
+ }
+ }
+ mCallTelemEnded = true;
+}
+
+DOMMediaStream* PeerConnectionImpl::GetReceiveStream(
+ const std::string& aId) const {
+ nsString wanted = NS_ConvertASCIItoUTF16(aId.c_str());
+ for (auto& stream : mReceiveStreams) {
+ nsString id;
+ stream->GetId(id);
+ if (id == wanted) {
+ return stream;
+ }
+ }
+ return nullptr;
+}
+
+DOMMediaStream* PeerConnectionImpl::CreateReceiveStream(
+ const std::string& aId) {
+ mReceiveStreams.AppendElement(new DOMMediaStream(mWindow));
+ mReceiveStreams.LastElement()->AssignId(NS_ConvertASCIItoUTF16(aId.c_str()));
+ return mReceiveStreams.LastElement();
+}
+
+already_AddRefed<dom::Promise> PeerConnectionImpl::OnSetDescriptionSuccess(
+ dom::RTCSdpType aSdpType, bool aRemote, ErrorResult& aError) {
+ CSFLogDebug(LOGTAG, __FUNCTION__);
+
+ RefPtr<dom::Promise> p = MakePromise(aError);
+ if (aError.Failed()) {
+ return nullptr;
+ }
+
+ DoSetDescriptionSuccessPostProcessing(aSdpType, aRemote, p);
+
+ return p.forget();
+}
+
+void PeerConnectionImpl::DoSetDescriptionSuccessPostProcessing(
+ dom::RTCSdpType aSdpType, bool aRemote, const RefPtr<dom::Promise>& aP) {
+ // Spec says we queue a task for all the stuff that ends up back in JS
+ GetMainThreadSerialEventTarget()->Dispatch(NS_NewRunnableFunction(
+ __func__,
+ [this, self = RefPtr<PeerConnectionImpl>(this), aSdpType, aRemote, aP] {
+ if (IsClosed()) {
+ // Yes, we do not settle the promise here. Yes, this is what the spec
+ // wants.
+ return;
+ }
+
+ MOZ_ASSERT(mUncommittedJsepSession);
+
+ // sRD/sLD needs to be redone in certain circumstances
+ bool needsRedo = HasPendingSetParameters();
+ if (!needsRedo && aRemote && (aSdpType == dom::RTCSdpType::Offer)) {
+ for (auto& transceiver : mTransceivers) {
+ if (!mUncommittedJsepSession->GetTransceiver(
+ transceiver->GetJsepTransceiverId())) {
+ needsRedo = true;
+ break;
+ }
+ }
+ }
+
+ if (needsRedo) {
+ // Spec says to abort, and re-do the sRD!
+ // This happens either when there is a SetParameters call in
+ // flight (that will race against the [[SendEncodings]]
+ // modification caused by sRD(offer)), or when addTrack has been
+ // called while sRD(offer) was in progress.
+ mUncommittedJsepSession.reset(mJsepSession->Clone());
+ JsepSession::Result result;
+ if (aRemote) {
+ mUncommittedJsepSession->SetRemoteDescription(
+ ToJsepSdpType(aSdpType), mRemoteRequestedSDP);
+ } else {
+ mUncommittedJsepSession->SetLocalDescription(
+ ToJsepSdpType(aSdpType), mLocalRequestedSDP);
+ }
+ if (result.mError.isSome()) {
+ // wat
+ nsCString error(
+ "When redoing sRD/sLD because it raced against "
+ "addTrack or setParameters, we encountered a failure that "
+ "did not happen "
+ "the first time. This should never happen. The error was: ");
+ error += mUncommittedJsepSession->GetLastError().c_str();
+ aP->MaybeRejectWithOperationError(error);
+ MOZ_ASSERT(false);
+ } else {
+ DoSetDescriptionSuccessPostProcessing(aSdpType, aRemote, aP);
+ }
+ return;
+ }
+
+ for (auto& transceiver : mTransceivers) {
+ if (!mUncommittedJsepSession->GetTransceiver(
+ transceiver->GetJsepTransceiverId())) {
+ // sLD, or sRD(answer), just make sure the new transceiver is
+ // added, no need to re-do anything.
+ mUncommittedJsepSession->AddTransceiver(
+ transceiver->GetJsepTransceiver());
+ }
+ }
+
+ auto oldIceCredentials = mJsepSession->GetLocalIceCredentials();
+ auto newIceCredentials =
+ mUncommittedJsepSession->GetLocalIceCredentials();
+
+ bool iceRestartDetected =
+ (!oldIceCredentials.empty() && !newIceCredentials.empty() &&
+ (oldIceCredentials != newIceCredentials));
+
+ mJsepSession = std::move(mUncommittedJsepSession);
+
+ auto newSignalingState = GetSignalingState();
+ SyncFromJsep();
+ if (aRemote || aSdpType == dom::RTCSdpType::Pranswer ||
+ aSdpType == dom::RTCSdpType::Answer) {
+ InvalidateLastReturnedParameters();
+ }
+
+ // Section 4.4.1.5 Set the RTCSessionDescription:
+ if (aSdpType == dom::RTCSdpType::Rollback) {
+ // - step 4.5.10, type is rollback
+ RollbackRTCDtlsTransports();
+ } else if (!(aRemote && aSdpType == dom::RTCSdpType::Offer)) {
+ // - step 4.5.9 type is not rollback
+ // - step 4.5.9.1 when remote is false
+ // - step 4.5.9.2.13 when remote is true, type answer or pranswer
+ // More simply: not rollback, and not for remote offers.
+ bool markAsStable = aSdpType == dom::RTCSdpType::Offer &&
+ mSignalingState == RTCSignalingState::Stable;
+ UpdateRTCDtlsTransports(markAsStable);
+ }
+
+ // Did we just apply a local description?
+ if (!aRemote) {
+ // We'd like to handle this in PeerConnectionImpl::UpdateNetworkState.
+ // Unfortunately, if the WiFi switch happens quickly, we never see
+ // that state change. We need to detect the ice restart here and
+ // reset the PeerConnectionImpl's stun addresses so they are
+ // regathered when PeerConnectionImpl::GatherIfReady is called.
+ if (iceRestartDetected || mJsepSession->IsIceRestarting()) {
+ ResetStunAddrsForIceRestart();
+ }
+ EnsureTransports(*mJsepSession);
+ }
+
+ if (mJsepSession->GetState() == kJsepStateStable) {
+ if (aSdpType != dom::RTCSdpType::Rollback) {
+ // We need this initted for UpdateTransports
+ InitializeDataChannel();
+ }
+
+ // If we're rolling back a local offer, we might need to remove some
+ // transports, and stomp some MediaPipeline setup, but nothing further
+ // needs to be done.
+ UpdateTransports(*mJsepSession, mForceIceTcp);
+ if (NS_FAILED(UpdateMediaPipelines())) {
+ CSFLogError(LOGTAG, "Error Updating MediaPipelines");
+ NS_ASSERTION(
+ false,
+ "Error Updating MediaPipelines in OnSetDescriptionSuccess()");
+ aP->MaybeRejectWithOperationError("Error Updating MediaPipelines");
+ }
+
+ if (aSdpType != dom::RTCSdpType::Rollback) {
+ StartIceChecks(*mJsepSession);
+ }
+
+ // Telemetry: record info on the current state of
+ // streams/renegotiations/etc Note: this code gets run on rollbacks as
+ // well!
+
+ // Update the max channels used with each direction for each type
+ uint16_t receiving[SdpMediaSection::kMediaTypes];
+ uint16_t sending[SdpMediaSection::kMediaTypes];
+ mJsepSession->CountTracksAndDatachannels(receiving, sending);
+ for (size_t i = 0; i < SdpMediaSection::kMediaTypes; i++) {
+ if (mMaxReceiving[i] < receiving[i]) {
+ mMaxReceiving[i] = receiving[i];
+ }
+ if (mMaxSending[i] < sending[i]) {
+ mMaxSending[i] = sending[i];
+ }
+ }
+ }
+
+ mPendingRemoteDescription =
+ mJsepSession->GetRemoteDescription(kJsepDescriptionPending);
+ mCurrentRemoteDescription =
+ mJsepSession->GetRemoteDescription(kJsepDescriptionCurrent);
+ mPendingLocalDescription =
+ mJsepSession->GetLocalDescription(kJsepDescriptionPending);
+ mCurrentLocalDescription =
+ mJsepSession->GetLocalDescription(kJsepDescriptionCurrent);
+ mPendingOfferer = mJsepSession->IsPendingOfferer();
+ mCurrentOfferer = mJsepSession->IsCurrentOfferer();
+
+ if (aSdpType == dom::RTCSdpType::Answer) {
+ std::set<std::pair<std::string, std::string>> iceCredentials =
+ mJsepSession->GetLocalIceCredentials();
+ std::vector<std::pair<std::string, std::string>>
+ iceCredentialsNotReplaced;
+ std::set_intersection(mLocalIceCredentialsToReplace.begin(),
+ mLocalIceCredentialsToReplace.end(),
+ iceCredentials.begin(), iceCredentials.end(),
+ std::back_inserter(iceCredentialsNotReplaced));
+
+ if (iceCredentialsNotReplaced.empty()) {
+ mLocalIceCredentialsToReplace.clear();
+ }
+ }
+
+ if (newSignalingState == RTCSignalingState::Stable) {
+ mNegotiationNeeded = false;
+ UpdateNegotiationNeeded();
+ }
+
+ bool signalingStateChanged = false;
+ if (newSignalingState != mSignalingState) {
+ mSignalingState = newSignalingState;
+ signalingStateChanged = true;
+ }
+
+ // Spec does not actually tell us to do this, but that is probably a
+ // spec bug.
+ // https://github.com/w3c/webrtc-pc/issues/2817
+ bool connectionStateChanged = UpdateConnectionState();
+
+ // This only gets populated for remote descriptions
+ dom::RTCRtpReceiver::StreamAssociationChanges changes;
+ if (aRemote) {
+ for (const auto& transceiver : mTransceivers) {
+ transceiver->Receiver()->UpdateStreams(&changes);
+ }
+ }
+
+ // Make sure to wait until after we've calculated track changes before
+ // doing this.
+ for (size_t i = 0; i < mTransceivers.Length();) {
+ auto& transceiver = mTransceivers[i];
+ if (transceiver->ShouldRemove()) {
+ mTransceivers[i]->Close();
+ mTransceivers[i]->SetRemovedFromPc();
+ mTransceivers.RemoveElementAt(i);
+ } else {
+ ++i;
+ }
+ }
+
+ // JS callbacks happen below. DO NOT TOUCH STATE AFTER THIS UNLESS SPEC
+ // EXPLICITLY SAYS TO, OTHERWISE STATES THAT ARE NOT SUPPOSED TO BE
+ // OBSERVABLE TO JS WILL BE!
+
+ JSErrorResult jrv;
+ RefPtr<PeerConnectionObserver> pcObserver(mPCObserver);
+ if (signalingStateChanged) {
+ pcObserver->OnStateChange(PCObserverStateType::SignalingState, jrv);
+ }
+
+ if (connectionStateChanged) {
+ pcObserver->OnStateChange(PCObserverStateType::ConnectionState, jrv);
+ }
+
+ for (const auto& receiver : changes.mReceiversToMute) {
+ // This sets the muted state for the recv track and all its clones.
+ receiver->SetTrackMuteFromRemoteSdp();
+ }
+
+ for (const auto& association : changes.mStreamAssociationsRemoved) {
+ RefPtr<DOMMediaStream> stream =
+ GetReceiveStream(association.mStreamId);
+ if (stream && stream->HasTrack(*association.mTrack)) {
+ stream->RemoveTrackInternal(association.mTrack);
+ }
+ }
+
+ // TODO(Bug 1241291): For legacy event, remove eventually
+ std::vector<RefPtr<DOMMediaStream>> newStreams;
+
+ for (const auto& association : changes.mStreamAssociationsAdded) {
+ RefPtr<DOMMediaStream> stream =
+ GetReceiveStream(association.mStreamId);
+ if (!stream) {
+ stream = CreateReceiveStream(association.mStreamId);
+ newStreams.push_back(stream);
+ }
+
+ if (!stream->HasTrack(*association.mTrack)) {
+ stream->AddTrackInternal(association.mTrack);
+ }
+ }
+
+ for (const auto& trackEvent : changes.mTrackEvents) {
+ dom::Sequence<OwningNonNull<DOMMediaStream>> streams;
+ for (const auto& id : trackEvent.mStreamIds) {
+ RefPtr<DOMMediaStream> stream = GetReceiveStream(id);
+ if (!stream) {
+ MOZ_ASSERT(false);
+ continue;
+ }
+ if (!streams.AppendElement(*stream, fallible)) {
+ // XXX(Bug 1632090) Instead of extending the array 1-by-1 (which
+ // might involve multiple reallocations) and potentially
+ // crashing here, SetCapacity could be called outside the loop
+ // once.
+ mozalloc_handle_oom(0);
+ }
+ }
+ pcObserver->FireTrackEvent(*trackEvent.mReceiver, streams, jrv);
+ }
+
+ // TODO(Bug 1241291): Legacy event, remove eventually
+ for (const auto& stream : newStreams) {
+ pcObserver->FireStreamEvent(*stream, jrv);
+ }
+ aP->MaybeResolveWithUndefined();
+ }));
+}
+
+void PeerConnectionImpl::OnSetDescriptionError() {
+ mUncommittedJsepSession = nullptr;
+}
+
+RTCSignalingState PeerConnectionImpl::GetSignalingState() const {
+ switch (mJsepSession->GetState()) {
+ case kJsepStateStable:
+ return RTCSignalingState::Stable;
+ break;
+ case kJsepStateHaveLocalOffer:
+ return RTCSignalingState::Have_local_offer;
+ break;
+ case kJsepStateHaveRemoteOffer:
+ return RTCSignalingState::Have_remote_offer;
+ break;
+ case kJsepStateHaveLocalPranswer:
+ return RTCSignalingState::Have_local_pranswer;
+ break;
+ case kJsepStateHaveRemotePranswer:
+ return RTCSignalingState::Have_remote_pranswer;
+ break;
+ case kJsepStateClosed:
+ return RTCSignalingState::Closed;
+ break;
+ }
+ MOZ_CRASH("Invalid JSEP state");
+}
+
+bool PeerConnectionImpl::IsClosed() const {
+ return mSignalingState == RTCSignalingState::Closed;
+}
+
+PeerConnectionWrapper::PeerConnectionWrapper(const std::string& handle)
+ : impl_(nullptr) {
+ if (PeerConnectionCtx::isActive()) {
+ impl_ = PeerConnectionCtx::GetInstance()->GetPeerConnection(handle);
+ }
+}
+
+const RefPtr<MediaTransportHandler> PeerConnectionImpl::GetTransportHandler()
+ const {
+ return mTransportHandler;
+}
+
+const std::string& PeerConnectionImpl::GetHandle() { return mHandle; }
+
+const std::string& PeerConnectionImpl::GetName() {
+ PC_AUTO_ENTER_API_CALL_NO_CHECK();
+ return mName;
+}
+
+void PeerConnectionImpl::CandidateReady(const std::string& candidate,
+ const std::string& transportId,
+ const std::string& ufrag) {
+ STAMP_TIMECARD(mTimeCard, "Ice Candidate gathered");
+ PC_AUTO_ENTER_API_CALL_VOID_RETURN(false);
+
+ if (mForceIceTcp && std::string::npos != candidate.find(" UDP ")) {
+ CSFLogWarn(LOGTAG, "Blocking local UDP candidate: %s", candidate.c_str());
+ STAMP_TIMECARD(mTimeCard, "UDP Ice Candidate blocked");
+ return;
+ }
+
+ // One of the very few places we still use level; required by the JSEP API
+ uint16_t level = 0;
+ std::string mid;
+ bool skipped = false;
+
+ if (mUncommittedJsepSession) {
+ // An sLD or sRD is in progress, and while that is the case, we need to add
+ // the candidate to both the current JSEP engine, and the uncommitted JSEP
+ // engine. We ignore errors because the spec says to only take into account
+ // the current/pending local descriptions when determining whether to
+ // surface the candidate to content, which does not take into account any
+ // in-progress sRD/sLD.
+ Unused << mUncommittedJsepSession->AddLocalIceCandidate(
+ candidate, transportId, ufrag, &level, &mid, &skipped);
+ }
+
+ nsresult res = mJsepSession->AddLocalIceCandidate(
+ candidate, transportId, ufrag, &level, &mid, &skipped);
+
+ if (NS_FAILED(res)) {
+ std::string errorString = mJsepSession->GetLastError();
+
+ STAMP_TIMECARD(mTimeCard, "Local Ice Candidate invalid");
+ CSFLogError(LOGTAG,
+ "Failed to incorporate local candidate into SDP:"
+ " res = %u, candidate = %s, transport-id = %s,"
+ " error = %s",
+ static_cast<unsigned>(res), candidate.c_str(),
+ transportId.c_str(), errorString.c_str());
+ return;
+ }
+
+ if (skipped) {
+ STAMP_TIMECARD(mTimeCard, "Local Ice Candidate skipped");
+ CSFLogInfo(LOGTAG,
+ "Skipped adding local candidate %s (transport-id %s) "
+ "to SDP, this typically happens because the m-section "
+ "is bundled, which means it doesn't make sense for it "
+ "to have its own transport-related attributes.",
+ candidate.c_str(), transportId.c_str());
+ return;
+ }
+
+ mPendingLocalDescription =
+ mJsepSession->GetLocalDescription(kJsepDescriptionPending);
+ mCurrentLocalDescription =
+ mJsepSession->GetLocalDescription(kJsepDescriptionCurrent);
+ CSFLogInfo(LOGTAG, "Passing local candidate to content: %s",
+ candidate.c_str());
+ SendLocalIceCandidateToContent(level, mid, candidate, ufrag);
+}
+
+void PeerConnectionImpl::SendLocalIceCandidateToContent(
+ uint16_t level, const std::string& mid, const std::string& candidate,
+ const std::string& ufrag) {
+ STAMP_TIMECARD(mTimeCard, "Send Ice Candidate to content");
+ JSErrorResult rv;
+ mPCObserver->OnIceCandidate(level, ObString(mid.c_str()),
+ ObString(candidate.c_str()),
+ ObString(ufrag.c_str()), rv);
+}
+
+void PeerConnectionImpl::IceConnectionStateChange(
+ dom::RTCIceConnectionState domState) {
+ PC_AUTO_ENTER_API_CALL_VOID_RETURN(false);
+
+ CSFLogDebug(LOGTAG, "%s: %d -> %d", __FUNCTION__,
+ static_cast<int>(mIceConnectionState),
+ static_cast<int>(domState));
+
+ if (domState == mIceConnectionState) {
+ // no work to be done since the states are the same.
+ // this can happen during ICE rollback situations.
+ return;
+ }
+
+ mIceConnectionState = domState;
+
+ // Would be nice if we had a means of converting one of these dom enums
+ // to a string that wasn't almost as much text as this switch statement...
+ switch (mIceConnectionState) {
+ case RTCIceConnectionState::New:
+ STAMP_TIMECARD(mTimeCard, "Ice state: new");
+ break;
+ case RTCIceConnectionState::Checking:
+ // For telemetry
+ mIceStartTime = TimeStamp::Now();
+ STAMP_TIMECARD(mTimeCard, "Ice state: checking");
+ break;
+ case RTCIceConnectionState::Connected:
+ STAMP_TIMECARD(mTimeCard, "Ice state: connected");
+ StartCallTelem();
+ break;
+ case RTCIceConnectionState::Completed:
+ STAMP_TIMECARD(mTimeCard, "Ice state: completed");
+ break;
+ case RTCIceConnectionState::Failed:
+ STAMP_TIMECARD(mTimeCard, "Ice state: failed");
+ break;
+ case RTCIceConnectionState::Disconnected:
+ STAMP_TIMECARD(mTimeCard, "Ice state: disconnected");
+ break;
+ case RTCIceConnectionState::Closed:
+ STAMP_TIMECARD(mTimeCard, "Ice state: closed");
+ break;
+ default:
+ MOZ_ASSERT_UNREACHABLE("Unexpected mIceConnectionState!");
+ }
+
+ bool connectionStateChanged = UpdateConnectionState();
+ WrappableJSErrorResult rv;
+ RefPtr<PeerConnectionObserver> pcObserver(mPCObserver);
+ pcObserver->OnStateChange(PCObserverStateType::IceConnectionState, rv);
+ if (connectionStateChanged) {
+ pcObserver->OnStateChange(PCObserverStateType::ConnectionState, rv);
+ }
+}
+
+void PeerConnectionImpl::OnCandidateFound(const std::string& aTransportId,
+ const CandidateInfo& aCandidateInfo) {
+ if (mStunAddrsRequest && !aCandidateInfo.mMDNSAddress.empty()) {
+ MOZ_ASSERT(!aCandidateInfo.mActualAddress.empty());
+
+ if (mCanRegisterMDNSHostnamesDirectly) {
+ auto itor = mRegisteredMDNSHostnames.find(aCandidateInfo.mMDNSAddress);
+
+ // We'll see the address twice if we're generating both UDP and TCP
+ // candidates.
+ if (itor == mRegisteredMDNSHostnames.end()) {
+ mRegisteredMDNSHostnames.insert(aCandidateInfo.mMDNSAddress);
+ mStunAddrsRequest->SendRegisterMDNSHostname(
+ nsCString(aCandidateInfo.mMDNSAddress.c_str()),
+ nsCString(aCandidateInfo.mActualAddress.c_str()));
+ }
+ } else {
+ mMDNSHostnamesToRegister.emplace(aCandidateInfo.mMDNSAddress,
+ aCandidateInfo.mActualAddress);
+ }
+ }
+
+ if (!aCandidateInfo.mDefaultHostRtp.empty()) {
+ UpdateDefaultCandidate(aCandidateInfo.mDefaultHostRtp,
+ aCandidateInfo.mDefaultPortRtp,
+ aCandidateInfo.mDefaultHostRtcp,
+ aCandidateInfo.mDefaultPortRtcp, aTransportId);
+ }
+ CandidateReady(aCandidateInfo.mCandidate, aTransportId,
+ aCandidateInfo.mUfrag);
+}
+
+void PeerConnectionImpl::IceGatheringStateChange(
+ dom::RTCIceGatheringState state) {
+ PC_AUTO_ENTER_API_CALL_VOID_RETURN(false);
+
+ CSFLogDebug(LOGTAG, "%s %d", __FUNCTION__, static_cast<int>(state));
+ if (mIceGatheringState == state) {
+ return;
+ }
+
+ mIceGatheringState = state;
+
+ // Would be nice if we had a means of converting one of these dom enums
+ // to a string that wasn't almost as much text as this switch statement...
+ switch (mIceGatheringState) {
+ case RTCIceGatheringState::New:
+ STAMP_TIMECARD(mTimeCard, "Ice gathering state: new");
+ break;
+ case RTCIceGatheringState::Gathering:
+ STAMP_TIMECARD(mTimeCard, "Ice gathering state: gathering");
+ break;
+ case RTCIceGatheringState::Complete:
+ STAMP_TIMECARD(mTimeCard, "Ice gathering state: complete");
+ break;
+ default:
+ MOZ_ASSERT_UNREACHABLE("Unexpected mIceGatheringState!");
+ }
+
+ JSErrorResult rv;
+ mPCObserver->OnStateChange(PCObserverStateType::IceGatheringState, rv);
+}
+
+void PeerConnectionImpl::UpdateDefaultCandidate(
+ const std::string& defaultAddr, uint16_t defaultPort,
+ const std::string& defaultRtcpAddr, uint16_t defaultRtcpPort,
+ const std::string& transportId) {
+ CSFLogDebug(LOGTAG, "%s", __FUNCTION__);
+ mJsepSession->UpdateDefaultCandidate(
+ defaultAddr, defaultPort, defaultRtcpAddr, defaultRtcpPort, transportId);
+ if (mUncommittedJsepSession) {
+ mUncommittedJsepSession->UpdateDefaultCandidate(
+ defaultAddr, defaultPort, defaultRtcpAddr, defaultRtcpPort,
+ transportId);
+ }
+}
+
+static UniquePtr<dom::RTCStatsCollection> GetDataChannelStats_s(
+ const RefPtr<DataChannelConnection>& aDataConnection,
+ const DOMHighResTimeStamp aTimestamp) {
+ UniquePtr<dom::RTCStatsCollection> report(new dom::RTCStatsCollection);
+ if (aDataConnection) {
+ aDataConnection->AppendStatsToReport(report, aTimestamp);
+ }
+ return report;
+}
+
+RefPtr<dom::RTCStatsPromise> PeerConnectionImpl::GetDataChannelStats(
+ const RefPtr<DataChannelConnection>& aDataChannelConnection,
+ const DOMHighResTimeStamp aTimestamp) {
+ // Gather stats from DataChannels
+ return InvokeAsync(
+ GetMainThreadSerialEventTarget(), __func__,
+ [aDataChannelConnection, aTimestamp]() {
+ return dom::RTCStatsPromise::CreateAndResolve(
+ GetDataChannelStats_s(aDataChannelConnection, aTimestamp),
+ __func__);
+ });
+}
+
+void PeerConnectionImpl::CollectConduitTelemetryData() {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ nsTArray<RefPtr<VideoSessionConduit>> conduits;
+ for (const auto& transceiver : mTransceivers) {
+ if (RefPtr<MediaSessionConduit> conduit = transceiver->GetConduit()) {
+ conduit->AsVideoSessionConduit().apply(
+ [&](const auto& aVideo) { conduits.AppendElement(aVideo); });
+ }
+ }
+
+ if (!conduits.IsEmpty() && mCall) {
+ mCall->mCallThread->Dispatch(
+ NS_NewRunnableFunction(__func__, [conduits = std::move(conduits)] {
+ for (const auto& conduit : conduits) {
+ conduit->CollectTelemetryData();
+ }
+ }));
+ }
+}
+
+nsTArray<dom::RTCCodecStats> PeerConnectionImpl::GetCodecStats(
+ DOMHighResTimeStamp aNow) {
+ MOZ_ASSERT(NS_IsMainThread());
+ nsTArray<dom::RTCCodecStats> result;
+
+ struct CodecComparator {
+ bool operator()(const JsepCodecDescription* aA,
+ const JsepCodecDescription* aB) const {
+ return aA->StatsId() < aB->StatsId();
+ }
+ };
+
+ // transportId -> codec; per direction (whether the codecType
+ // shall be "encode", "decode" or absent (if a codec exists in both maps for a
+ // transport)). These do the bookkeeping to ensure codec stats get coalesced
+ // to transport level.
+ std::map<std::string, std::set<JsepCodecDescription*, CodecComparator>>
+ sendCodecMap;
+ std::map<std::string, std::set<JsepCodecDescription*, CodecComparator>>
+ recvCodecMap;
+
+ // Find all JsepCodecDescription instances we want to turn into codec stats.
+ for (const auto& transceiver : mTransceivers) {
+ // TODO: Grab these from the JSEP transceivers instead
+ auto sendCodecs = transceiver->GetNegotiatedSendCodecs();
+ auto recvCodecs = transceiver->GetNegotiatedRecvCodecs();
+
+ const std::string transportId = transceiver->GetTransportId();
+ // This ensures both codec maps have the same size.
+ auto& sendMap = sendCodecMap[transportId];
+ auto& recvMap = recvCodecMap[transportId];
+
+ sendCodecs.apply([&](const auto& aCodecs) {
+ for (const auto& codec : aCodecs) {
+ sendMap.insert(codec.get());
+ }
+ });
+ recvCodecs.apply([&](const auto& aCodecs) {
+ for (const auto& codec : aCodecs) {
+ recvMap.insert(codec.get());
+ }
+ });
+ }
+
+ auto createCodecStat = [&](const JsepCodecDescription* aCodec,
+ const nsString& aTransportId,
+ Maybe<RTCCodecType> aCodecType) {
+ uint16_t pt;
+ {
+ DebugOnly<bool> rv = aCodec->GetPtAsInt(&pt);
+ MOZ_ASSERT(rv);
+ }
+ nsString mimeType;
+ mimeType.AppendPrintf(
+ "%s/%s", aCodec->Type() == SdpMediaSection::kVideo ? "video" : "audio",
+ aCodec->mName.c_str());
+ nsString id = aTransportId;
+ id.Append(u"_");
+ id.Append(aCodec->StatsId());
+
+ dom::RTCCodecStats codec;
+ codec.mId.Construct(std::move(id));
+ codec.mTimestamp.Construct(aNow);
+ codec.mType.Construct(RTCStatsType::Codec);
+ codec.mPayloadType = pt;
+ if (aCodecType) {
+ codec.mCodecType.Construct(*aCodecType);
+ }
+ codec.mTransportId = aTransportId;
+ codec.mMimeType = std::move(mimeType);
+ codec.mClockRate.Construct(aCodec->mClock);
+ if (aCodec->Type() == SdpMediaSection::MediaType::kAudio) {
+ codec.mChannels.Construct(aCodec->mChannels);
+ }
+ if (aCodec->mSdpFmtpLine) {
+ codec.mSdpFmtpLine.Construct(
+ NS_ConvertUTF8toUTF16(aCodec->mSdpFmtpLine->c_str()));
+ }
+
+ result.AppendElement(std::move(codec));
+ };
+
+ // Create codec stats for the gathered codec descriptions, sorted primarily
+ // by transportId, secondarily by payload type (from StatsId()).
+ for (const auto& [transportId, sendCodecs] : sendCodecMap) {
+ const auto& recvCodecs = recvCodecMap[transportId];
+ const nsString tid = NS_ConvertASCIItoUTF16(transportId);
+ AutoTArray<JsepCodecDescription*, 16> bidirectionalCodecs;
+ AutoTArray<JsepCodecDescription*, 16> unidirectionalCodecs;
+ std::set_intersection(sendCodecs.cbegin(), sendCodecs.cend(),
+ recvCodecs.cbegin(), recvCodecs.cend(),
+ MakeBackInserter(bidirectionalCodecs),
+ CodecComparator());
+ std::set_symmetric_difference(sendCodecs.cbegin(), sendCodecs.cend(),
+ recvCodecs.cbegin(), recvCodecs.cend(),
+ MakeBackInserter(unidirectionalCodecs),
+ CodecComparator());
+ for (const auto* codec : bidirectionalCodecs) {
+ createCodecStat(codec, tid, Nothing());
+ }
+ for (const auto* codec : unidirectionalCodecs) {
+ createCodecStat(
+ codec, tid,
+ Some(codec->mDirection == sdp::kSend ? RTCCodecType::Encode
+ : RTCCodecType::Decode));
+ }
+ }
+
+ return result;
+}
+
+RefPtr<dom::RTCStatsReportPromise> PeerConnectionImpl::GetStats(
+ dom::MediaStreamTrack* aSelector, bool aInternalStats) {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ if (mFinalStatsQuery) {
+ // This case should be _extremely_ rare; this will basically only happen
+ // when WebrtcGlobalInformation tries to get our stats while we are tearing
+ // down.
+ return mFinalStatsQuery->Then(
+ GetMainThreadSerialEventTarget(), __func__,
+ [this, self = RefPtr<PeerConnectionImpl>(this)]() {
+ UniquePtr<dom::RTCStatsReportInternal> finalStats =
+ MakeUnique<dom::RTCStatsReportInternal>();
+ // Might not be set if this encountered some error.
+ if (mFinalStats) {
+ *finalStats = *mFinalStats;
+ }
+ return RTCStatsReportPromise::CreateAndResolve(std::move(finalStats),
+ __func__);
+ });
+ }
+
+ nsTArray<RefPtr<dom::RTCStatsPromise>> promises;
+ DOMHighResTimeStamp now = mTimestampMaker.GetNow().ToDom();
+
+ nsTArray<dom::RTCCodecStats> codecStats = GetCodecStats(now);
+ std::set<std::string> transportIds;
+
+ if (!aSelector) {
+ // There might not be any senders/receivers if we're DataChannel only, so we
+ // don't handle the null selector case in the loop below.
+ transportIds.insert("");
+ }
+
+ nsTArray<
+ std::tuple<RTCRtpTransceiver*, RefPtr<RTCStatsPromise::AllPromiseType>>>
+ transceiverStatsPromises;
+ for (const auto& transceiver : mTransceivers) {
+ const bool sendSelected = transceiver->Sender()->HasTrack(aSelector);
+ const bool recvSelected = transceiver->Receiver()->HasTrack(aSelector);
+ if (!sendSelected && !recvSelected) {
+ continue;
+ }
+
+ if (aSelector) {
+ transportIds.insert(transceiver->GetTransportId());
+ }
+
+ nsTArray<RefPtr<RTCStatsPromise>> rtpStreamPromises;
+ // Get all rtp stream stats for the given selector. Then filter away any
+ // codec stat not related to the selector, and assign codec ids to the
+ // stream stats.
+ // Skips the ICE stats; we do our own queries based on |transportIds| to
+ // avoid duplicates
+ if (sendSelected) {
+ rtpStreamPromises.AppendElements(
+ transceiver->Sender()->GetStatsInternal(true));
+ }
+ if (recvSelected) {
+ rtpStreamPromises.AppendElements(
+ transceiver->Receiver()->GetStatsInternal(true));
+ }
+ transceiverStatsPromises.AppendElement(
+ std::make_tuple(transceiver.get(),
+ RTCStatsPromise::All(GetMainThreadSerialEventTarget(),
+ rtpStreamPromises)));
+ }
+
+ promises.AppendElement(RTCRtpTransceiver::ApplyCodecStats(
+ std::move(codecStats), std::move(transceiverStatsPromises)));
+
+ for (const auto& transportId : transportIds) {
+ promises.AppendElement(mTransportHandler->GetIceStats(transportId, now));
+ }
+
+ promises.AppendElement(GetDataChannelStats(mDataConnection, now));
+
+ auto pcStatsCollection = MakeUnique<dom::RTCStatsCollection>();
+ RTCPeerConnectionStats pcStats;
+ pcStats.mTimestamp.Construct(now);
+ pcStats.mType.Construct(RTCStatsType::Peer_connection);
+ pcStats.mId.Construct(NS_ConvertUTF8toUTF16(mHandle.c_str()));
+ pcStats.mDataChannelsOpened.Construct(mDataChannelsOpened);
+ pcStats.mDataChannelsClosed.Construct(mDataChannelsClosed);
+ if (!pcStatsCollection->mPeerConnectionStats.AppendElement(std::move(pcStats),
+ fallible)) {
+ mozalloc_handle_oom(0);
+ }
+ promises.AppendElement(RTCStatsPromise::CreateAndResolve(
+ std::move(pcStatsCollection), __func__));
+
+ // This is what we're going to return; all the stuff in |promises| will be
+ // accumulated here.
+ UniquePtr<dom::RTCStatsReportInternal> report(
+ new dom::RTCStatsReportInternal);
+ report->mPcid = NS_ConvertASCIItoUTF16(mName.c_str());
+ if (mWindow && mWindow->GetBrowsingContext()) {
+ report->mBrowserId = mWindow->GetBrowsingContext()->BrowserId();
+ }
+ report->mConfiguration.Construct(mJsConfiguration);
+ // TODO(bug 1589416): We need to do better here.
+ if (!mIceStartTime.IsNull()) {
+ report->mCallDurationMs.Construct(
+ (TimeStamp::Now() - mIceStartTime).ToMilliseconds());
+ }
+ report->mIceRestarts = mIceRestartCount;
+ report->mIceRollbacks = mIceRollbackCount;
+ report->mClosed = false;
+ report->mTimestamp = now;
+
+ if (aInternalStats && mJsepSession) {
+ for (const auto& candidate : mRawTrickledCandidates) {
+ if (!report->mRawRemoteCandidates.AppendElement(
+ NS_ConvertASCIItoUTF16(candidate.c_str()), fallible)) {
+ // XXX(Bug 1632090) Instead of extending the array 1-by-1 (which might
+ // involve multiple reallocations) and potentially crashing here,
+ // SetCapacity could be called outside the loop once.
+ mozalloc_handle_oom(0);
+ }
+ }
+
+ if (mJsepSession) {
+ // TODO we probably should report Current and Pending SDPs here
+ // separately. Plus the raw SDP we got from JS (mLocalRequestedSDP).
+ // And if it's the offer or answer would also be nice.
+ std::string localDescription =
+ mJsepSession->GetLocalDescription(kJsepDescriptionPendingOrCurrent);
+ std::string remoteDescription =
+ mJsepSession->GetRemoteDescription(kJsepDescriptionPendingOrCurrent);
+ if (!report->mSdpHistory.AppendElements(mSdpHistory, fallible)) {
+ mozalloc_handle_oom(0);
+ }
+ if (mJsepSession->IsPendingOfferer().isSome()) {
+ report->mOfferer.Construct(*mJsepSession->IsPendingOfferer());
+ } else if (mJsepSession->IsCurrentOfferer().isSome()) {
+ report->mOfferer.Construct(*mJsepSession->IsCurrentOfferer());
+ } else {
+ // Silly.
+ report->mOfferer.Construct(false);
+ }
+ }
+ }
+
+ return dom::RTCStatsPromise::All(GetMainThreadSerialEventTarget(), promises)
+ ->Then(
+ GetMainThreadSerialEventTarget(), __func__,
+ [report = std::move(report), idGen = mIdGenerator](
+ nsTArray<UniquePtr<dom::RTCStatsCollection>> aStats) mutable {
+ idGen->RewriteIds(std::move(aStats), report.get());
+ return dom::RTCStatsReportPromise::CreateAndResolve(
+ std::move(report), __func__);
+ },
+ [](nsresult rv) {
+ return dom::RTCStatsReportPromise::CreateAndReject(rv, __func__);
+ });
+}
+
+void PeerConnectionImpl::RecordIceRestartStatistics(JsepSdpType type) {
+ switch (type) {
+ case mozilla::kJsepSdpOffer:
+ case mozilla::kJsepSdpPranswer:
+ break;
+ case mozilla::kJsepSdpAnswer:
+ ++mIceRestartCount;
+ break;
+ case mozilla::kJsepSdpRollback:
+ ++mIceRollbackCount;
+ break;
+ }
+}
+
+void PeerConnectionImpl::StoreConfigurationForAboutWebrtc(
+ const dom::RTCConfiguration& aConfig) {
+ // This will only be called once, when the PeerConnection is initially
+ // configured, at least until setConfiguration is implemented
+ // see https://bugzilla.mozilla.org/show_bug.cgi?id=1253706
+ // @TODO bug 1739451 call this from setConfiguration
+ mJsConfiguration.mIceServers.Clear();
+ for (const auto& server : aConfig.mIceServers) {
+ RTCIceServerInternal internal;
+ internal.mCredentialProvided = server.mCredential.WasPassed();
+ internal.mUserNameProvided = server.mUsername.WasPassed();
+ if (server.mUrl.WasPassed()) {
+ if (!internal.mUrls.AppendElement(server.mUrl.Value(), fallible)) {
+ mozalloc_handle_oom(0);
+ }
+ }
+ if (server.mUrls.WasPassed()) {
+ for (const auto& url : server.mUrls.Value().GetAsStringSequence()) {
+ if (!internal.mUrls.AppendElement(url, fallible)) {
+ mozalloc_handle_oom(0);
+ }
+ }
+ }
+ if (!mJsConfiguration.mIceServers.AppendElement(internal, fallible)) {
+ mozalloc_handle_oom(0);
+ }
+ }
+ mJsConfiguration.mSdpSemantics.Reset();
+ if (aConfig.mSdpSemantics.WasPassed()) {
+ mJsConfiguration.mSdpSemantics.Construct(aConfig.mSdpSemantics.Value());
+ }
+
+ mJsConfiguration.mIceTransportPolicy.Reset();
+ mJsConfiguration.mIceTransportPolicy.Construct(aConfig.mIceTransportPolicy);
+ mJsConfiguration.mBundlePolicy.Reset();
+ mJsConfiguration.mBundlePolicy.Construct(aConfig.mBundlePolicy);
+ mJsConfiguration.mPeerIdentityProvided = !aConfig.mPeerIdentity.IsEmpty();
+ mJsConfiguration.mCertificatesProvided = !aConfig.mCertificates.Length();
+}
+
+dom::Sequence<dom::RTCSdpParsingErrorInternal>
+PeerConnectionImpl::GetLastSdpParsingErrors() const {
+ const auto& sdpErrors = mJsepSession->GetLastSdpParsingErrors();
+ dom::Sequence<dom::RTCSdpParsingErrorInternal> domErrors;
+ if (!domErrors.SetCapacity(domErrors.Length(), fallible)) {
+ mozalloc_handle_oom(0);
+ }
+ for (const auto& error : sdpErrors) {
+ mozilla::dom::RTCSdpParsingErrorInternal internal;
+ internal.mLineNumber = error.first;
+ if (!AppendASCIItoUTF16(MakeStringSpan(error.second.c_str()),
+ internal.mError, fallible)) {
+ mozalloc_handle_oom(0);
+ }
+ if (!domErrors.AppendElement(std::move(internal), fallible)) {
+ mozalloc_handle_oom(0);
+ }
+ }
+ return domErrors;
+}
+
+// Telemetry for when calls start
+void PeerConnectionImpl::StartCallTelem() {
+ if (mCallTelemStarted) {
+ return;
+ }
+ MOZ_RELEASE_ASSERT(mWindow);
+ uint64_t windowId = mWindow->WindowID();
+ auto found = sCallDurationTimers.find(windowId);
+ if (found == sCallDurationTimers.end()) {
+ found =
+ sCallDurationTimers.emplace(windowId, PeerConnectionAutoTimer()).first;
+ }
+ found->second.RegisterConnection();
+ mCallTelemStarted = true;
+
+ // Increment session call counter
+ // If we want to track Loop calls independently here, we need two
+ // histograms.
+ //
+ // NOTE: As of bug 1654248 landing we are no longer counting renegotiations
+ // as separate calls. Expect numbers to drop compared to
+ // WEBRTC_CALL_COUNT_2.
+ Telemetry::Accumulate(Telemetry::WEBRTC_CALL_COUNT_3, 1);
+}
+
+void PeerConnectionImpl::StunAddrsHandler::OnMDNSQueryComplete(
+ const nsCString& hostname, const Maybe<nsCString>& address) {
+ MOZ_ASSERT(NS_IsMainThread());
+ PeerConnectionWrapper pcw(mPcHandle);
+ if (!pcw.impl()) {
+ return;
+ }
+ auto itor = pcw.impl()->mQueriedMDNSHostnames.find(hostname.BeginReading());
+ if (itor != pcw.impl()->mQueriedMDNSHostnames.end()) {
+ if (address) {
+ for (auto& cand : itor->second) {
+ // Replace obfuscated address with actual address
+ std::string obfuscatedAddr = cand.mTokenizedCandidate[4];
+ cand.mTokenizedCandidate[4] = address->BeginReading();
+ std::ostringstream o;
+ for (size_t i = 0; i < cand.mTokenizedCandidate.size(); ++i) {
+ o << cand.mTokenizedCandidate[i];
+ if (i + 1 != cand.mTokenizedCandidate.size()) {
+ o << " ";
+ }
+ }
+ std::string mungedCandidate = o.str();
+ pcw.impl()->StampTimecard("Done looking up mDNS name");
+ pcw.impl()->mTransportHandler->AddIceCandidate(
+ cand.mTransportId, mungedCandidate, cand.mUfrag, obfuscatedAddr);
+ }
+ } else {
+ pcw.impl()->StampTimecard("Failed looking up mDNS name");
+ }
+ pcw.impl()->mQueriedMDNSHostnames.erase(itor);
+ }
+}
+
+void PeerConnectionImpl::StunAddrsHandler::OnStunAddrsAvailable(
+ const mozilla::net::NrIceStunAddrArray& addrs) {
+ CSFLogInfo(LOGTAG, "%s: receiving (%d) stun addrs", __FUNCTION__,
+ (int)addrs.Length());
+ PeerConnectionWrapper pcw(mPcHandle);
+ if (!pcw.impl()) {
+ return;
+ }
+ pcw.impl()->mStunAddrs = addrs.Clone();
+ pcw.impl()->mLocalAddrsRequestState = STUN_ADDR_REQUEST_COMPLETE;
+ pcw.impl()->FlushIceCtxOperationQueueIfReady();
+ // If parent process returns 0 STUN addresses, change ICE connection
+ // state to failed.
+ if (!pcw.impl()->mStunAddrs.Length()) {
+ pcw.impl()->IceConnectionStateChange(dom::RTCIceConnectionState::Failed);
+ }
+}
+
+void PeerConnectionImpl::InitLocalAddrs() {
+ if (mLocalAddrsRequestState == STUN_ADDR_REQUEST_PENDING) {
+ return;
+ }
+ if (mStunAddrsRequest) {
+ mLocalAddrsRequestState = STUN_ADDR_REQUEST_PENDING;
+ mStunAddrsRequest->SendGetStunAddrs();
+ } else {
+ mLocalAddrsRequestState = STUN_ADDR_REQUEST_COMPLETE;
+ }
+}
+
+bool PeerConnectionImpl::ShouldForceProxy() const {
+ if (Preferences::GetBool("media.peerconnection.ice.proxy_only", false)) {
+ return true;
+ }
+
+ bool isPBM = false;
+ // This complicated null check is being extra conservative to avoid
+ // introducing crashes. It may not be needed.
+ if (mWindow && mWindow->GetExtantDoc() &&
+ mWindow->GetExtantDoc()->GetPrincipal() &&
+ mWindow->GetExtantDoc()
+ ->GetPrincipal()
+ ->OriginAttributesRef()
+ .mPrivateBrowsingId > 0) {
+ isPBM = true;
+ }
+
+ if (isPBM && Preferences::GetBool(
+ "media.peerconnection.ice.proxy_only_if_pbmode", false)) {
+ return true;
+ }
+
+ if (!Preferences::GetBool(
+ "media.peerconnection.ice.proxy_only_if_behind_proxy", false)) {
+ return false;
+ }
+
+ // Ok, we're supposed to be proxy_only, but only if a proxy is configured.
+ // Let's just see if the document was loaded via a proxy.
+
+ nsCOMPtr<nsIHttpChannelInternal> httpChannelInternal = GetChannel();
+ if (!httpChannelInternal) {
+ return false;
+ }
+
+ bool proxyUsed = false;
+ Unused << httpChannelInternal->GetIsProxyUsed(&proxyUsed);
+ return proxyUsed;
+}
+
+void PeerConnectionImpl::EnsureTransports(const JsepSession& aSession) {
+ mJsepSession->ForEachTransceiver([this,
+ self = RefPtr<PeerConnectionImpl>(this)](
+ const JsepTransceiver& transceiver) {
+ if (transceiver.HasOwnTransport()) {
+ mTransportHandler->EnsureProvisionalTransport(
+ transceiver.mTransport.mTransportId,
+ transceiver.mTransport.mLocalUfrag, transceiver.mTransport.mLocalPwd,
+ transceiver.mTransport.mComponents);
+ }
+ });
+
+ GatherIfReady();
+}
+
+void PeerConnectionImpl::UpdateRTCDtlsTransports(bool aMarkAsStable) {
+ mJsepSession->ForEachTransceiver(
+ [this, self = RefPtr<PeerConnectionImpl>(this)](
+ const JsepTransceiver& jsepTransceiver) {
+ std::string transportId = jsepTransceiver.mTransport.mTransportId;
+ if (transportId.empty()) {
+ return;
+ }
+ if (!mTransportIdToRTCDtlsTransport.count(transportId)) {
+ mTransportIdToRTCDtlsTransport.emplace(
+ transportId, new RTCDtlsTransport(GetParentObject()));
+ }
+ });
+
+ for (auto& transceiver : mTransceivers) {
+ std::string transportId = transceiver->GetTransportId();
+ if (transportId.empty()) {
+ continue;
+ }
+ if (mTransportIdToRTCDtlsTransport.count(transportId)) {
+ transceiver->SetDtlsTransport(mTransportIdToRTCDtlsTransport[transportId],
+ aMarkAsStable);
+ }
+ }
+
+ // Spec says we only update the RTCSctpTransport when negotiation completes
+}
+
+void PeerConnectionImpl::RollbackRTCDtlsTransports() {
+ for (auto& transceiver : mTransceivers) {
+ transceiver->RollbackToStableDtlsTransport();
+ }
+}
+
+void PeerConnectionImpl::RemoveRTCDtlsTransportsExcept(
+ const std::set<std::string>& aTransportIds) {
+ for (auto iter = mTransportIdToRTCDtlsTransport.begin();
+ iter != mTransportIdToRTCDtlsTransport.end();) {
+ if (!aTransportIds.count(iter->first)) {
+ iter = mTransportIdToRTCDtlsTransport.erase(iter);
+ } else {
+ ++iter;
+ }
+ }
+}
+
+nsresult PeerConnectionImpl::UpdateTransports(const JsepSession& aSession,
+ const bool forceIceTcp) {
+ std::set<std::string> finalTransports;
+ Maybe<std::string> sctpTransport;
+ mJsepSession->ForEachTransceiver(
+ [&, this, self = RefPtr<PeerConnectionImpl>(this)](
+ const JsepTransceiver& transceiver) {
+ if (transceiver.GetMediaType() == SdpMediaSection::kApplication &&
+ transceiver.HasTransport()) {
+ sctpTransport = Some(transceiver.mTransport.mTransportId);
+ }
+
+ if (transceiver.HasOwnTransport()) {
+ finalTransports.insert(transceiver.mTransport.mTransportId);
+ UpdateTransport(transceiver, forceIceTcp);
+ }
+ });
+
+ // clean up the unused RTCDtlsTransports
+ RemoveRTCDtlsTransportsExcept(finalTransports);
+
+ mTransportHandler->RemoveTransportsExcept(finalTransports);
+
+ for (const auto& transceiverImpl : mTransceivers) {
+ transceiverImpl->UpdateTransport();
+ }
+
+ if (sctpTransport.isSome()) {
+ auto it = mTransportIdToRTCDtlsTransport.find(*sctpTransport);
+ if (it == mTransportIdToRTCDtlsTransport.end()) {
+ // What?
+ MOZ_ASSERT(false);
+ return NS_ERROR_FAILURE;
+ }
+ if (!mDataConnection) {
+ // What?
+ MOZ_ASSERT(false);
+ return NS_ERROR_FAILURE;
+ }
+ RefPtr<RTCDtlsTransport> dtlsTransport = it->second;
+ // Why on earth does the spec use a floating point for this?
+ double maxMessageSize =
+ static_cast<double>(mDataConnection->GetMaxMessageSize());
+ Nullable<uint16_t> maxChannels;
+
+ if (!mSctpTransport) {
+ mSctpTransport = new RTCSctpTransport(GetParentObject(), *dtlsTransport,
+ maxMessageSize, maxChannels);
+ } else {
+ mSctpTransport->SetTransport(*dtlsTransport);
+ mSctpTransport->SetMaxMessageSize(maxMessageSize);
+ mSctpTransport->SetMaxChannels(maxChannels);
+ }
+ } else {
+ mSctpTransport = nullptr;
+ }
+
+ return NS_OK;
+}
+
+void PeerConnectionImpl::UpdateTransport(const JsepTransceiver& aTransceiver,
+ bool aForceIceTcp) {
+ std::string ufrag;
+ std::string pwd;
+ std::vector<std::string> candidates;
+ size_t components = 0;
+
+ const JsepTransport& transport = aTransceiver.mTransport;
+ unsigned level = aTransceiver.GetLevel();
+
+ CSFLogDebug(LOGTAG, "ACTIVATING TRANSPORT! - PC %s: level=%u components=%u",
+ mHandle.c_str(), (unsigned)level,
+ (unsigned)transport.mComponents);
+
+ ufrag = transport.mIce->GetUfrag();
+ pwd = transport.mIce->GetPassword();
+ candidates = transport.mIce->GetCandidates();
+ components = transport.mComponents;
+ if (aForceIceTcp) {
+ candidates.erase(
+ std::remove_if(candidates.begin(), candidates.end(),
+ [](const std::string& s) {
+ return s.find(" UDP ") != std::string::npos ||
+ s.find(" udp ") != std::string::npos;
+ }),
+ candidates.end());
+ }
+
+ nsTArray<uint8_t> keyDer;
+ nsTArray<uint8_t> certDer;
+ nsresult rv = Identity()->Serialize(&keyDer, &certDer);
+ if (NS_FAILED(rv)) {
+ CSFLogError(LOGTAG, "%s: Failed to serialize DTLS identity: %d",
+ __FUNCTION__, (int)rv);
+ return;
+ }
+
+ DtlsDigestList digests;
+ for (const auto& fingerprint :
+ transport.mDtls->GetFingerprints().mFingerprints) {
+ digests.emplace_back(ToString(fingerprint.hashFunc),
+ fingerprint.fingerprint);
+ }
+
+ mTransportHandler->ActivateTransport(
+ transport.mTransportId, transport.mLocalUfrag, transport.mLocalPwd,
+ components, ufrag, pwd, keyDer, certDer, Identity()->auth_type(),
+ transport.mDtls->GetRole() == JsepDtlsTransport::kJsepDtlsClient, digests,
+ PrivacyRequested());
+
+ for (auto& candidate : candidates) {
+ AddIceCandidate("candidate:" + candidate, transport.mTransportId, ufrag);
+ }
+}
+
+nsresult PeerConnectionImpl::UpdateMediaPipelines() {
+ for (RefPtr<RTCRtpTransceiver>& transceiver : mTransceivers) {
+ transceiver->ResetSync();
+ }
+
+ for (RefPtr<RTCRtpTransceiver>& transceiver : mTransceivers) {
+ if (!transceiver->IsVideo()) {
+ nsresult rv = transceiver->SyncWithMatchingVideoConduits(mTransceivers);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+ }
+
+ transceiver->UpdatePrincipalPrivacy(PrivacyRequested()
+ ? PrincipalPrivacy::Private
+ : PrincipalPrivacy::NonPrivate);
+
+ nsresult rv = transceiver->UpdateConduit();
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+ }
+
+ return NS_OK;
+}
+
+void PeerConnectionImpl::StartIceChecks(const JsepSession& aSession) {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ if (!mCanRegisterMDNSHostnamesDirectly) {
+ for (auto& pair : mMDNSHostnamesToRegister) {
+ mRegisteredMDNSHostnames.insert(pair.first);
+ mStunAddrsRequest->SendRegisterMDNSHostname(
+ nsCString(pair.first.c_str()), nsCString(pair.second.c_str()));
+ }
+ mMDNSHostnamesToRegister.clear();
+ mCanRegisterMDNSHostnamesDirectly = true;
+ }
+
+ std::vector<std::string> attributes;
+ if (aSession.RemoteIsIceLite()) {
+ attributes.push_back("ice-lite");
+ }
+
+ if (!aSession.GetIceOptions().empty()) {
+ attributes.push_back("ice-options:");
+ for (const auto& option : aSession.GetIceOptions()) {
+ attributes.back() += option + ' ';
+ }
+ }
+
+ nsCOMPtr<nsIRunnable> runnable(
+ WrapRunnable(mTransportHandler, &MediaTransportHandler::StartIceChecks,
+ aSession.IsIceControlling(), attributes));
+
+ PerformOrEnqueueIceCtxOperation(runnable);
+}
+
+bool PeerConnectionImpl::GetPrefDefaultAddressOnly() const {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ uint64_t winId = mWindow->WindowID();
+
+ bool default_address_only = Preferences::GetBool(
+ "media.peerconnection.ice.default_address_only", false);
+ default_address_only |=
+ !MediaManager::Get()->IsActivelyCapturingOrHasAPermission(winId);
+ return default_address_only;
+}
+
+bool PeerConnectionImpl::GetPrefObfuscateHostAddresses() const {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ uint64_t winId = mWindow->WindowID();
+
+ bool obfuscate_host_addresses = Preferences::GetBool(
+ "media.peerconnection.ice.obfuscate_host_addresses", false);
+ obfuscate_host_addresses &=
+ !MediaManager::Get()->IsActivelyCapturingOrHasAPermission(winId);
+ obfuscate_host_addresses &= !PeerConnectionImpl::HostnameInPref(
+ "media.peerconnection.ice.obfuscate_host_addresses.blocklist", mHostname);
+ obfuscate_host_addresses &= XRE_IsContentProcess();
+
+ return obfuscate_host_addresses;
+}
+
+PeerConnectionImpl::SignalHandler::SignalHandler(PeerConnectionImpl* aPc,
+ MediaTransportHandler* aSource)
+ : mHandle(aPc->GetHandle()),
+ mSource(aSource),
+ mSTSThread(aPc->GetSTSThread()),
+ mPacketDumper(aPc->GetPacketDumper()) {
+ ConnectSignals();
+}
+
+PeerConnectionImpl::SignalHandler::~SignalHandler() {
+ ASSERT_ON_THREAD(mSTSThread);
+}
+
+void PeerConnectionImpl::SignalHandler::ConnectSignals() {
+ mSource->SignalGatheringStateChange.connect(
+ this, &PeerConnectionImpl::SignalHandler::IceGatheringStateChange_s);
+ mSource->SignalConnectionStateChange.connect(
+ this, &PeerConnectionImpl::SignalHandler::IceConnectionStateChange_s);
+ mSource->SignalCandidate.connect(
+ this, &PeerConnectionImpl::SignalHandler::OnCandidateFound_s);
+ mSource->SignalAlpnNegotiated.connect(
+ this, &PeerConnectionImpl::SignalHandler::AlpnNegotiated_s);
+ mSource->SignalStateChange.connect(
+ this, &PeerConnectionImpl::SignalHandler::ConnectionStateChange_s);
+ mSource->SignalRtcpStateChange.connect(
+ this, &PeerConnectionImpl::SignalHandler::ConnectionStateChange_s);
+ mSource->SignalPacketReceived.connect(
+ this, &PeerConnectionImpl::SignalHandler::OnPacketReceived_s);
+}
+
+void PeerConnectionImpl::AddIceCandidate(const std::string& aCandidate,
+ const std::string& aTransportId,
+ const std::string& aUfrag) {
+ MOZ_ASSERT(NS_IsMainThread());
+ MOZ_ASSERT(!aTransportId.empty());
+
+ bool obfuscate_host_addresses = Preferences::GetBool(
+ "media.peerconnection.ice.obfuscate_host_addresses", false);
+
+ if (obfuscate_host_addresses && !RelayOnly()) {
+ std::vector<std::string> tokens;
+ TokenizeCandidate(aCandidate, tokens);
+
+ if (tokens.size() > 4) {
+ std::string addr = tokens[4];
+
+ // Check for address ending with .local
+ size_t nPeriods = std::count(addr.begin(), addr.end(), '.');
+ size_t dotLocalLength = 6; // length of ".local"
+
+ if (nPeriods == 1 &&
+ addr.rfind(".local") + dotLocalLength == addr.length()) {
+ if (mStunAddrsRequest) {
+ PendingIceCandidate cand;
+ cand.mTokenizedCandidate = std::move(tokens);
+ cand.mTransportId = aTransportId;
+ cand.mUfrag = aUfrag;
+ mQueriedMDNSHostnames[addr].push_back(cand);
+
+ GetMainThreadSerialEventTarget()->Dispatch(NS_NewRunnableFunction(
+ "PeerConnectionImpl::SendQueryMDNSHostname",
+ [self = RefPtr<PeerConnectionImpl>(this), addr]() mutable {
+ if (self->mStunAddrsRequest) {
+ self->StampTimecard("Look up mDNS name");
+ self->mStunAddrsRequest->SendQueryMDNSHostname(
+ nsCString(nsAutoCString(addr.c_str())));
+ }
+ NS_ReleaseOnMainThread(
+ "PeerConnectionImpl::SendQueryMDNSHostname", self.forget());
+ }));
+ }
+ // TODO: Bug 1535690, we don't want to tell the ICE context that remote
+ // trickle is done if we are waiting to resolve a mDNS candidate.
+ return;
+ }
+ }
+ }
+
+ mTransportHandler->AddIceCandidate(aTransportId, aCandidate, aUfrag, "");
+}
+
+void PeerConnectionImpl::UpdateNetworkState(bool online) {
+ if (mTransportHandler) {
+ mTransportHandler->UpdateNetworkState(online);
+ }
+}
+
+void PeerConnectionImpl::FlushIceCtxOperationQueueIfReady() {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ if (IsIceCtxReady()) {
+ for (auto& queuedIceCtxOperation : mQueuedIceCtxOperations) {
+ queuedIceCtxOperation->Run();
+ }
+ mQueuedIceCtxOperations.clear();
+ }
+}
+
+void PeerConnectionImpl::PerformOrEnqueueIceCtxOperation(
+ nsIRunnable* runnable) {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ if (IsIceCtxReady()) {
+ runnable->Run();
+ } else {
+ mQueuedIceCtxOperations.push_back(runnable);
+ }
+}
+
+void PeerConnectionImpl::GatherIfReady() {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ // Init local addrs here so that if we re-gather after an ICE restart
+ // resulting from changing WiFi networks, we get new local addrs.
+ // Otherwise, we would reuse the addrs from the original WiFi network
+ // and the ICE restart will fail.
+ if (!mStunAddrs.Length()) {
+ InitLocalAddrs();
+ }
+
+ // If we had previously queued gathering or ICE start, unqueue them
+ mQueuedIceCtxOperations.clear();
+ nsCOMPtr<nsIRunnable> runnable(WrapRunnable(
+ RefPtr<PeerConnectionImpl>(this), &PeerConnectionImpl::EnsureIceGathering,
+ GetPrefDefaultAddressOnly(), GetPrefObfuscateHostAddresses()));
+
+ PerformOrEnqueueIceCtxOperation(runnable);
+}
+
+already_AddRefed<nsIHttpChannelInternal> PeerConnectionImpl::GetChannel()
+ const {
+ Document* doc = mWindow->GetExtantDoc();
+ if (NS_WARN_IF(!doc)) {
+ NS_WARNING("Unable to get document from window");
+ return nullptr;
+ }
+
+ if (!doc->GetDocumentURI()->SchemeIs("file")) {
+ nsIChannel* channel = doc->GetChannel();
+ if (!channel) {
+ NS_WARNING("Unable to get channel from document");
+ return nullptr;
+ }
+
+ nsCOMPtr<nsIHttpChannelInternal> httpChannelInternal =
+ do_QueryInterface(channel);
+ if (NS_WARN_IF(!httpChannelInternal)) {
+ CSFLogInfo(LOGTAG, "%s: Document does not have an HTTP channel",
+ __FUNCTION__);
+ return nullptr;
+ }
+ return httpChannelInternal.forget();
+ }
+ return nullptr;
+}
+
+nsresult PeerConnectionImpl::SetTargetForDefaultLocalAddressLookup() {
+ nsCOMPtr<nsIHttpChannelInternal> httpChannelInternal = GetChannel();
+ if (!httpChannelInternal) {
+ return NS_OK;
+ }
+
+ nsCString remoteIp;
+ nsresult rv = httpChannelInternal->GetRemoteAddress(remoteIp);
+ if (NS_FAILED(rv) || remoteIp.IsEmpty()) {
+ CSFLogError(LOGTAG, "%s: Failed to get remote IP address: %d", __FUNCTION__,
+ (int)rv);
+ return rv;
+ }
+
+ int32_t remotePort;
+ rv = httpChannelInternal->GetRemotePort(&remotePort);
+ if (NS_FAILED(rv)) {
+ CSFLogError(LOGTAG, "%s: Failed to get remote port number: %d",
+ __FUNCTION__, (int)rv);
+ return rv;
+ }
+
+ mTransportHandler->SetTargetForDefaultLocalAddressLookup(remoteIp.get(),
+ remotePort);
+
+ return NS_OK;
+}
+
+void PeerConnectionImpl::EnsureIceGathering(bool aDefaultRouteOnly,
+ bool aObfuscateHostAddresses) {
+ if (!mTargetForDefaultLocalAddressLookupIsSet) {
+ nsresult rv = SetTargetForDefaultLocalAddressLookup();
+ if (NS_FAILED(rv)) {
+ NS_WARNING("Unable to set target for default local address lookup");
+ }
+ mTargetForDefaultLocalAddressLookupIsSet = true;
+ }
+
+ // Make sure we don't call StartIceGathering if we're in e10s mode
+ // and we received no STUN addresses from the parent process. In the
+ // absence of previously provided STUN addresses, StartIceGathering will
+ // attempt to gather them (as in non-e10s mode), and this will cause a
+ // sandboxing exception in e10s mode.
+ if (!mStunAddrs.Length() && XRE_IsContentProcess()) {
+ CSFLogInfo(LOGTAG, "%s: No STUN addresses returned from parent process",
+ __FUNCTION__);
+ return;
+ }
+
+ mTransportHandler->StartIceGathering(aDefaultRouteOnly,
+ aObfuscateHostAddresses, mStunAddrs);
+}
+
+already_AddRefed<dom::RTCRtpTransceiver> PeerConnectionImpl::CreateTransceiver(
+ const std::string& aId, bool aIsVideo, const RTCRtpTransceiverInit& aInit,
+ dom::MediaStreamTrack* aSendTrack, bool aAddTrackMagic, ErrorResult& aRv) {
+ PeerConnectionCtx* ctx = PeerConnectionCtx::GetInstance();
+ if (!mCall) {
+ mCall = WebrtcCallWrapper::Create(
+ GetTimestampMaker(),
+ media::ShutdownBlockingTicket::Create(
+ u"WebrtcCallWrapper shutdown blocker"_ns,
+ NS_LITERAL_STRING_FROM_CSTRING(__FILE__), __LINE__),
+ ctx->GetSharedWebrtcState());
+ mRtcpReceiveListener = mSignalHandler->RtcpReceiveEvent().Connect(
+ mCall->mCallThread, [call = mCall](MediaPacket aPacket) {
+ // This might not be initted yet, because the task to do that is tail
+ // dispatched, and STS might beat it to the punch.
+ if (call->Call()) {
+ call->Call()->Receiver()->DeliverRtcpPacket(
+ rtc::CopyOnWriteBuffer(aPacket.data(), aPacket.len()));
+ }
+ });
+ }
+
+ if (aAddTrackMagic) {
+ mJsepSession->ApplyToTransceiver(aId, [](JsepTransceiver& aTransceiver) {
+ aTransceiver.SetAddTrackMagic();
+ });
+ }
+
+ RefPtr<RTCRtpTransceiver> transceiver = new RTCRtpTransceiver(
+ mWindow, PrivacyRequested(), this, mTransportHandler, mJsepSession.get(),
+ aId, aIsVideo, mSTSThread.get(), aSendTrack, mCall.get(), mIdGenerator);
+
+ transceiver->Init(aInit, aRv);
+ if (aRv.Failed()) {
+ return nullptr;
+ }
+
+ if (aSendTrack) {
+ // implement checking for peerIdentity (where failure == black/silence)
+ Document* doc = mWindow->GetExtantDoc();
+ if (doc) {
+ transceiver->Sender()->GetPipeline()->UpdateSinkIdentity(
+ doc->NodePrincipal(), GetPeerIdentity());
+ } else {
+ MOZ_CRASH();
+ aRv = NS_ERROR_FAILURE;
+ return nullptr; // Don't remove this till we know it's safe.
+ }
+ }
+
+ return transceiver.forget();
+}
+
+std::string PeerConnectionImpl::GetTransportIdMatchingSendTrack(
+ const dom::MediaStreamTrack& aTrack) const {
+ for (const RefPtr<RTCRtpTransceiver>& transceiver : mTransceivers) {
+ if (transceiver->Sender()->HasTrack(&aTrack)) {
+ return transceiver->GetTransportId();
+ }
+ }
+ return std::string();
+}
+
+void PeerConnectionImpl::SignalHandler::IceGatheringStateChange_s(
+ dom::RTCIceGatheringState aState) {
+ ASSERT_ON_THREAD(mSTSThread);
+
+ GetMainThreadSerialEventTarget()->Dispatch(
+ NS_NewRunnableFunction(__func__,
+ [handle = mHandle, aState] {
+ PeerConnectionWrapper wrapper(handle);
+ if (wrapper.impl()) {
+ wrapper.impl()->IceGatheringStateChange(
+ aState);
+ }
+ }),
+ NS_DISPATCH_NORMAL);
+}
+
+void PeerConnectionImpl::SignalHandler::IceConnectionStateChange_s(
+ dom::RTCIceConnectionState aState) {
+ ASSERT_ON_THREAD(mSTSThread);
+
+ GetMainThreadSerialEventTarget()->Dispatch(
+ NS_NewRunnableFunction(__func__,
+ [handle = mHandle, aState] {
+ PeerConnectionWrapper wrapper(handle);
+ if (wrapper.impl()) {
+ wrapper.impl()->IceConnectionStateChange(
+ aState);
+ }
+ }),
+ NS_DISPATCH_NORMAL);
+}
+
+void PeerConnectionImpl::SignalHandler::OnCandidateFound_s(
+ const std::string& aTransportId, const CandidateInfo& aCandidateInfo) {
+ ASSERT_ON_THREAD(mSTSThread);
+ CSFLogDebug(LOGTAG, "%s: %s", __FUNCTION__, aTransportId.c_str());
+
+ MOZ_ASSERT(!aCandidateInfo.mUfrag.empty());
+
+ GetMainThreadSerialEventTarget()->Dispatch(
+ NS_NewRunnableFunction(__func__,
+ [handle = mHandle, aTransportId, aCandidateInfo] {
+ PeerConnectionWrapper wrapper(handle);
+ if (wrapper.impl()) {
+ wrapper.impl()->OnCandidateFound(
+ aTransportId, aCandidateInfo);
+ }
+ }),
+ NS_DISPATCH_NORMAL);
+}
+
+void PeerConnectionImpl::SignalHandler::AlpnNegotiated_s(
+ const std::string& aAlpn, bool aPrivacyRequested) {
+ MOZ_DIAGNOSTIC_ASSERT((aAlpn == "c-webrtc") == aPrivacyRequested);
+ GetMainThreadSerialEventTarget()->Dispatch(
+ NS_NewRunnableFunction(__func__,
+ [handle = mHandle, aPrivacyRequested] {
+ PeerConnectionWrapper wrapper(handle);
+ if (wrapper.impl()) {
+ wrapper.impl()->OnAlpnNegotiated(
+ aPrivacyRequested);
+ }
+ }),
+ NS_DISPATCH_NORMAL);
+}
+
+void PeerConnectionImpl::SignalHandler::ConnectionStateChange_s(
+ const std::string& aTransportId, TransportLayer::State aState) {
+ GetMainThreadSerialEventTarget()->Dispatch(
+ NS_NewRunnableFunction(__func__,
+ [handle = mHandle, aTransportId, aState] {
+ PeerConnectionWrapper wrapper(handle);
+ if (wrapper.impl()) {
+ wrapper.impl()->OnDtlsStateChange(aTransportId,
+ aState);
+ }
+ }),
+ NS_DISPATCH_NORMAL);
+}
+
+void PeerConnectionImpl::SignalHandler::OnPacketReceived_s(
+ const std::string& aTransportId, const MediaPacket& aPacket) {
+ ASSERT_ON_THREAD(mSTSThread);
+
+ if (!aPacket.len()) {
+ return;
+ }
+
+ if (aPacket.type() != MediaPacket::RTCP) {
+ return;
+ }
+
+ CSFLogVerbose(LOGTAG, "%s received RTCP packet.", mHandle.c_str());
+
+ RtpLogger::LogPacket(aPacket, true, mHandle);
+
+ // Might be nice to pass ownership of the buffer in this case, but it is a
+ // small optimization in a rare case.
+ mPacketDumper->Dump(SIZE_MAX, dom::mozPacketDumpType::Srtcp, false,
+ aPacket.encrypted_data(), aPacket.encrypted_len());
+
+ mPacketDumper->Dump(SIZE_MAX, dom::mozPacketDumpType::Rtcp, false,
+ aPacket.data(), aPacket.len());
+
+ if (StaticPrefs::media_webrtc_net_force_disable_rtcp_reception()) {
+ CSFLogVerbose(LOGTAG, "%s RTCP packet forced to be dropped",
+ mHandle.c_str());
+ return;
+ }
+
+ mRtcpReceiveEvent.Notify(aPacket.Clone());
+}
+
+/**
+ * Tells you if any local track is isolated to a specific peer identity.
+ * Obviously, we want all the tracks to be isolated equally so that they can
+ * all be sent or not. We check once when we are setting a local description
+ * and that determines if we flip the "privacy requested" bit on. Once the bit
+ * is on, all media originating from this peer connection is isolated.
+ *
+ * @returns true if any track has a peerIdentity set on it
+ */
+bool PeerConnectionImpl::AnyLocalTrackHasPeerIdentity() const {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ for (const RefPtr<RTCRtpTransceiver>& transceiver : mTransceivers) {
+ if (transceiver->Sender()->GetTrack() &&
+ transceiver->Sender()->GetTrack()->GetPeerIdentity()) {
+ return true;
+ }
+ }
+ return false;
+}
+
+bool PeerConnectionImpl::AnyCodecHasPluginID(uint64_t aPluginID) {
+ for (RefPtr<RTCRtpTransceiver>& transceiver : mTransceivers) {
+ if (transceiver->ConduitHasPluginID(aPluginID)) {
+ return true;
+ }
+ }
+ return false;
+}
+
+std::unique_ptr<NrSocketProxyConfig> PeerConnectionImpl::GetProxyConfig()
+ const {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ if (!mForceProxy &&
+ Preferences::GetBool("media.peerconnection.disable_http_proxy", false)) {
+ return nullptr;
+ }
+
+ nsCString alpn = "webrtc,c-webrtc"_ns;
+ auto* browserChild = BrowserChild::GetFrom(mWindow);
+ if (!browserChild) {
+ // Android doesn't have browser child apparently...
+ return nullptr;
+ }
+
+ Document* doc = mWindow->GetExtantDoc();
+ if (NS_WARN_IF(!doc)) {
+ NS_WARNING("Unable to get document from window");
+ return nullptr;
+ }
+
+ TabId id = browserChild->GetTabId();
+ nsCOMPtr<nsILoadInfo> loadInfo =
+ new net::LoadInfo(doc->NodePrincipal(), doc->NodePrincipal(), doc, 0,
+ nsIContentPolicy::TYPE_INVALID);
+
+ net::LoadInfoArgs loadInfoArgs;
+ MOZ_ALWAYS_SUCCEEDS(
+ mozilla::ipc::LoadInfoToLoadInfoArgs(loadInfo, &loadInfoArgs));
+ return std::unique_ptr<NrSocketProxyConfig>(new NrSocketProxyConfig(
+ net::WebrtcProxyConfig(id, alpn, loadInfoArgs, mForceProxy)));
+}
+
+std::map<uint64_t, PeerConnectionAutoTimer>
+ PeerConnectionImpl::sCallDurationTimers;
+} // namespace mozilla