diff options
Diffstat (limited to '')
36 files changed, 16250 insertions, 0 deletions
diff --git a/dom/media/webrtc/jsapi/MediaTransportHandler.cpp b/dom/media/webrtc/jsapi/MediaTransportHandler.cpp new file mode 100644 index 0000000000..3ee95f36f6 --- /dev/null +++ b/dom/media/webrtc/jsapi/MediaTransportHandler.cpp @@ -0,0 +1,1727 @@ +/* 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 "MediaTransportHandler.h" +#include "MediaTransportHandlerIPC.h" +#include "transport/nricemediastream.h" +#include "transport/nriceresolver.h" +#include "transport/transportflow.h" +#include "transport/transportlayerice.h" +#include "transport/transportlayerdtls.h" +#include "transport/transportlayersrtp.h" + +// Config stuff +#include "mozilla/dom/RTCConfigurationBinding.h" +#include "mozilla/Preferences.h" +#include "mozilla/StaticPrefs_network.h" + +// Parsing STUN/TURN URIs +#include "nsIURI.h" +#include "nsNetUtil.h" +#include "nsURLHelper.h" +#include "nsIURLParser.h" + +// Logging stuff +#include "common/browser_logging/CSFLog.h" + +// For fetching ICE logging +#include "transport/rlogconnector.h" + +// DTLS +#include "sdp/SdpAttribute.h" + +#include "transport/runnable_utils.h" + +#include "mozilla/Algorithm.h" +#include "mozilla/Telemetry.h" + +#include "mozilla/dom/RTCStatsReportBinding.h" + +#include "nss.h" // For NSS_NoDB_Init +#include "mozilla/PublicSSL.h" // For psm::InitializeCipherSuite + +#include "nsISocketTransportService.h" +#include "nsDNSService2.h" + +#include <string> +#include <vector> +#include <map> + +#ifdef MOZ_GECKO_PROFILER +# include "mozilla/ProfilerMarkers.h" + +# define MEDIA_TRANSPORT_HANDLER_PACKET_RECEIVED(aPacket) \ + PROFILER_MARKER_TEXT("WebRTC Packet Received", MEDIA_RT, {}, \ + ProfilerString8View::WrapNullTerminatedString( \ + PacketTypeToString((aPacket).type()))); +#else +# define MEDIA_TRANSPORT_HANDLER_PACKET_RECEIVED(aPacket) +#endif + +namespace mozilla { + +static const char* mthLogTag = "MediaTransportHandler"; +#ifdef LOGTAG +# undef LOGTAG +#endif +#define LOGTAG mthLogTag + +class MediaTransportHandlerSTS : public MediaTransportHandler, + public sigslot::has_slots<> { + public: + explicit MediaTransportHandlerSTS(nsISerialEventTarget* aCallbackThread); + + RefPtr<IceLogPromise> GetIceLog(const nsCString& aPattern) override; + void ClearIceLog() override; + void EnterPrivateMode() override; + void ExitPrivateMode() override; + + void CreateIceCtx(const std::string& aName) override; + + nsresult SetIceConfig(const nsTArray<dom::RTCIceServer>& aIceServers, + dom::RTCIceTransportPolicy aIcePolicy) override; + + // We will probably be able to move the proxy lookup stuff into + // this class once we move mtransport to its own process. + void SetProxyConfig(NrSocketProxyConfig&& aProxyConfig) override; + + void EnsureProvisionalTransport(const std::string& aTransportId, + const std::string& aUfrag, + const std::string& aPwd, + int aComponentCount) override; + + void SetTargetForDefaultLocalAddressLookup(const std::string& aTargetIp, + uint16_t aTargetPort) override; + + // We set default-route-only as late as possible because it depends on what + // capture permissions have been granted on the window, which could easily + // change between Init (ie; when the PC is created) and StartIceGathering + // (ie; when we set the local description). + void StartIceGathering(bool aDefaultRouteOnly, bool aObfuscateHostAddresses, + // This will go away once mtransport moves to its + // own process, because we won't need to get this + // via IPC anymore + const nsTArray<NrIceStunAddr>& aStunAddrs) override; + + void ActivateTransport( + const std::string& aTransportId, const std::string& aLocalUfrag, + const std::string& aLocalPwd, size_t aComponentCount, + const std::string& aUfrag, const std::string& aPassword, + const nsTArray<uint8_t>& aKeyDer, const nsTArray<uint8_t>& aCertDer, + SSLKEAType aAuthType, bool aDtlsClient, const DtlsDigestList& aDigests, + bool aPrivacyRequested) override; + + void RemoveTransportsExcept( + const std::set<std::string>& aTransportIds) override; + + void StartIceChecks(bool aIsControlling, + const std::vector<std::string>& aIceOptions) override; + + void AddIceCandidate(const std::string& aTransportId, + const std::string& aCandidate, const std::string& aUfrag, + const std::string& aObfuscatedAddress) override; + + void UpdateNetworkState(bool aOnline) override; + + void SendPacket(const std::string& aTransportId, + MediaPacket&& aPacket) override; + + RefPtr<dom::RTCStatsPromise> GetIceStats(const std::string& aTransportId, + DOMHighResTimeStamp aNow) override; + + void Shutdown(); + + private: + void Destroy() override; + void Destroy_s(); + void DestroyFinal(); + void Shutdown_s(); + RefPtr<TransportFlow> CreateTransportFlow( + const std::string& aTransportId, bool aIsRtcp, + const RefPtr<DtlsIdentity>& aDtlsIdentity, bool aDtlsClient, + const DtlsDigestList& aDigests, bool aPrivacyRequested); + + struct Transport { + RefPtr<TransportFlow> mFlow; + RefPtr<TransportFlow> mRtcpFlow; + }; + + using MediaTransportHandler::OnAlpnNegotiated; + using MediaTransportHandler::OnCandidate; + using MediaTransportHandler::OnConnectionStateChange; + using MediaTransportHandler::OnEncryptedSending; + using MediaTransportHandler::OnGatheringStateChange; + using MediaTransportHandler::OnPacketReceived; + using MediaTransportHandler::OnRtcpStateChange; + using MediaTransportHandler::OnStateChange; + + void OnGatheringStateChange(NrIceCtx* aIceCtx, + NrIceCtx::GatheringState aState); + void OnConnectionStateChange(NrIceCtx* aIceCtx, + NrIceCtx::ConnectionState aState); + void OnCandidateFound(NrIceMediaStream* aStream, + const std::string& aCandidate, + const std::string& aUfrag, const std::string& aMDNSAddr, + const std::string& aActualAddr); + void OnStateChange(TransportLayer* aLayer, TransportLayer::State); + void OnRtcpStateChange(TransportLayer* aLayer, TransportLayer::State); + void PacketReceived(TransportLayer* aLayer, MediaPacket& aPacket); + void EncryptedPacketSending(TransportLayer* aLayer, MediaPacket& aPacket); + RefPtr<TransportFlow> GetTransportFlow(const std::string& aTransportId, + bool aIsRtcp) const; + void GetIceStats(const NrIceMediaStream& aStream, DOMHighResTimeStamp aNow, + dom::RTCStatsCollection* aStats) const; + + virtual ~MediaTransportHandlerSTS() = default; + nsCOMPtr<nsISerialEventTarget> mStsThread; + RefPtr<NrIceCtx> mIceCtx; + RefPtr<NrIceResolver> mDNSResolver; + std::map<std::string, Transport> mTransports; + bool mObfuscateHostAddresses = false; + bool mTurnDisabled = false; + uint32_t mMinDtlsVersion = 0; + uint32_t mMaxDtlsVersion = 0; + bool mForceNoHost = false; + Maybe<NrIceCtx::NatSimulatorConfig> mNatConfig; + + std::set<std::string> mSignaledAddresses; + + // Init can only be done on main, but we want this to be usable on any thread + using InitPromise = MozPromise<bool, std::string, false>; + RefPtr<InitPromise> mInitPromise; +}; + +/* static */ +already_AddRefed<MediaTransportHandler> MediaTransportHandler::Create( + nsISerialEventTarget* aCallbackThread) { + RefPtr<MediaTransportHandler> result; + if (XRE_IsContentProcess() && + Preferences::GetBool("media.peerconnection.mtransport_process") && + StaticPrefs::network_process_enabled()) { + result = new MediaTransportHandlerIPC(aCallbackThread); + } else { + result = new MediaTransportHandlerSTS(aCallbackThread); + } + result->Initialize(); + return result.forget(); +} + +class STSShutdownHandler : public nsISTSShutdownObserver { + public: + NS_DECL_ISUPPORTS + + // Lazy singleton + static RefPtr<STSShutdownHandler>& Instance() { + MOZ_ASSERT(NS_IsMainThread()); + static RefPtr<STSShutdownHandler> sHandler(new STSShutdownHandler); + return sHandler; + } + + void Shutdown() { + MOZ_ASSERT(NS_IsMainThread()); + for (const auto& handler : mHandlers) { + handler->Shutdown(); + } + mHandlers.clear(); + } + + STSShutdownHandler() { + CSFLogDebug(LOGTAG, "%s", __func__); + nsresult res; + nsCOMPtr<nsISocketTransportService> sts = + do_GetService(NS_SOCKETTRANSPORTSERVICE_CONTRACTID, &res); + MOZ_RELEASE_ASSERT(NS_SUCCEEDED(res)); + MOZ_RELEASE_ASSERT(sts); + sts->AddShutdownObserver(this); + } + + NS_IMETHOD Observe() override { + CSFLogDebug(LOGTAG, "%s", __func__); + Shutdown(); + nsresult res; + nsCOMPtr<nsISocketTransportService> sts = + do_GetService(NS_SOCKETTRANSPORTSERVICE_CONTRACTID, &res); + MOZ_RELEASE_ASSERT(NS_SUCCEEDED(res)); + MOZ_RELEASE_ASSERT(sts); + sts->RemoveShutdownObserver(this); + Instance() = nullptr; + return NS_OK; + } + + void Register(MediaTransportHandlerSTS* aHandler) { + MOZ_ASSERT(NS_IsMainThread()); + mHandlers.insert(aHandler); + } + + void Deregister(MediaTransportHandlerSTS* aHandler) { + MOZ_ASSERT(NS_IsMainThread()); + mHandlers.erase(aHandler); + } + + private: + virtual ~STSShutdownHandler() = default; + + // Raw ptrs, registered on init, deregistered on destruction, all on main + std::set<MediaTransportHandlerSTS*> mHandlers; +}; + +NS_IMPL_ISUPPORTS(STSShutdownHandler, nsISTSShutdownObserver); + +MediaTransportHandlerSTS::MediaTransportHandlerSTS( + nsISerialEventTarget* aCallbackThread) + : MediaTransportHandler(aCallbackThread) { + nsresult rv; + mStsThread = do_GetService(NS_SOCKETTRANSPORTSERVICE_CONTRACTID, &rv); + if (!mStsThread) { + MOZ_CRASH(); + } + + RLogConnector::CreateInstance(); + + CSFLogDebug(LOGTAG, "%s done %p", __func__, this); + + // We do not set up mDNSService here, because we are not running on main (we + // use PBackground), and the DNS service asserts. +} + +static NrIceCtx::Policy toNrIcePolicy(dom::RTCIceTransportPolicy aPolicy) { + switch (aPolicy) { + case dom::RTCIceTransportPolicy::Relay: + return NrIceCtx::ICE_POLICY_RELAY; + case dom::RTCIceTransportPolicy::All: + return NrIceCtx::ICE_POLICY_ALL; + default: + MOZ_CRASH(); + } + return NrIceCtx::ICE_POLICY_ALL; +} + +// list of known acceptable ports for webrtc +int16_t gGoodWebrtcPortList[] = { + 53, // Some deplyoments use DNS port to punch through overzealous NATs + 3478, // stun or turn + 5349, // stuns or turns + 0, // Sentinel value: This MUST be zero +}; + +static nsresult addNrIceServer(const nsString& aIceUrl, + const dom::RTCIceServer& aIceServer, + std::vector<NrIceStunServer>* aStunServersOut, + std::vector<NrIceTurnServer>* aTurnServersOut) { + // Without STUN/TURN handlers, NS_NewURI returns nsSimpleURI rather than + // nsStandardURL. To parse STUN/TURN URI's to spec + // http://tools.ietf.org/html/draft-nandakumar-rtcweb-stun-uri-02#section-3 + // http://tools.ietf.org/html/draft-petithuguenin-behave-turn-uri-03#section-3 + // we parse out the query-string, and use ParseAuthority() on the rest + RefPtr<nsIURI> url; + nsresult rv = NS_NewURI(getter_AddRefs(url), aIceUrl); + NS_ENSURE_SUCCESS(rv, rv); + bool isStun = url->SchemeIs("stun"); + bool isStuns = url->SchemeIs("stuns"); + bool isTurn = url->SchemeIs("turn"); + bool isTurns = url->SchemeIs("turns"); + if (!(isStun || isStuns || isTurn || isTurns)) { + return NS_ERROR_FAILURE; + } + if (isStuns) { + return NS_OK; // TODO: Support STUNS (Bug 1056934) + } + + nsAutoCString spec; + rv = url->GetSpec(spec); + NS_ENSURE_SUCCESS(rv, rv); + + // TODO(jib@mozilla.com): Revisit once nsURI supports STUN/TURN (Bug 833509) + int32_t port; + nsAutoCString host; + nsAutoCString transport; + { + uint32_t hostPos; + int32_t hostLen; + nsAutoCString path; + rv = url->GetPathQueryRef(path); + NS_ENSURE_SUCCESS(rv, rv); + + // Tolerate query-string + parse 'transport=[udp|tcp]' by hand. + int32_t questionmark = path.FindChar('?'); + if (questionmark >= 0) { + const nsCString match = "transport="_ns; + + for (int32_t i = questionmark, endPos; i >= 0; i = endPos) { + endPos = path.FindCharInSet("&", i + 1); + const nsDependentCSubstring fieldvaluepair = + Substring(path, i + 1, endPos); + if (StringBeginsWith(fieldvaluepair, match)) { + transport = Substring(fieldvaluepair, match.Length()); + ToLowerCase(transport); + } + } + path.SetLength(questionmark); + } + + rv = net_GetAuthURLParser()->ParseAuthority( + path.get(), static_cast<int>(path.Length()), nullptr, nullptr, nullptr, + nullptr, &hostPos, &hostLen, &port); + NS_ENSURE_SUCCESS(rv, rv); + if (!hostLen) { + return NS_ERROR_FAILURE; + } + if (hostPos > 1) { + /* The username was removed */ + return NS_ERROR_FAILURE; + } + path.Mid(host, hostPos, hostLen); + // Strip off brackets around IPv6 literals + host.Trim("[]"); + } + if (port == -1) port = (isStuns || isTurns) ? 5349 : 3478; + + // First check the known good ports for webrtc + bool goodPort = false; + for (int i = 0; !goodPort && gGoodWebrtcPortList[i]; i++) { + if (port == gGoodWebrtcPortList[i]) { + goodPort = true; + } + } + + // if not in the list of known good ports for webrtc, check + // the generic block list using NS_CheckPortSafety. + if (!goodPort) { + rv = NS_CheckPortSafety(port, nullptr); + NS_ENSURE_SUCCESS(rv, rv); + } + + if (isStuns || isTurns) { + // Should we barf if transport is set to udp or something? + transport = kNrIceTransportTls; + } + + if (transport.IsEmpty()) { + transport = kNrIceTransportUdp; + } + + if (isTurn || isTurns) { + std::string pwd( + NS_ConvertUTF16toUTF8(aIceServer.mCredential.Value()).get()); + std::string username( + NS_ConvertUTF16toUTF8(aIceServer.mUsername.Value()).get()); + + std::vector<unsigned char> password(pwd.begin(), pwd.end()); + + UniquePtr<NrIceTurnServer> server(NrIceTurnServer::Create( + host.get(), port, username, password, transport.get())); + if (!server) { + return NS_ERROR_FAILURE; + } + if (server->HasFqdn()) { + // Add an IPv4 entry, then an IPv6 entry + aTurnServersOut->push_back(*server); + server->SetUseIPv6IfFqdn(); + } + aTurnServersOut->emplace_back(std::move(*server)); + } else { + UniquePtr<NrIceStunServer> server( + NrIceStunServer::Create(host.get(), port, transport.get())); + if (!server) { + return NS_ERROR_FAILURE; + } + if (server->HasFqdn()) { + // Add an IPv4 entry, then an IPv6 entry + aStunServersOut->push_back(*server); + server->SetUseIPv6IfFqdn(); + } + aStunServersOut->emplace_back(std::move(*server)); + } + return NS_OK; +} + +/* static */ +nsresult MediaTransportHandler::ConvertIceServers( + const nsTArray<dom::RTCIceServer>& aIceServers, + std::vector<NrIceStunServer>* aStunServers, + std::vector<NrIceTurnServer>* aTurnServers) { + for (const auto& iceServer : aIceServers) { + NS_ENSURE_STATE(iceServer.mUrls.WasPassed()); + NS_ENSURE_STATE(iceServer.mUrls.Value().IsStringSequence()); + for (const auto& iceUrl : iceServer.mUrls.Value().GetAsStringSequence()) { + nsresult rv = + addNrIceServer(iceUrl, iceServer, aStunServers, aTurnServers); + if (NS_FAILED(rv)) { + CSFLogError(LOGTAG, "%s: invalid STUN/TURN server: %s", __FUNCTION__, + NS_ConvertUTF16toUTF8(iceUrl).get()); + return rv; + } + } + } + + return NS_OK; +} + +static NrIceCtx::GlobalConfig GetGlobalConfig() { + NrIceCtx::GlobalConfig config; + config.mAllowLinkLocal = + Preferences::GetBool("media.peerconnection.ice.link_local", false); + config.mAllowLoopback = + Preferences::GetBool("media.peerconnection.ice.loopback", false); + config.mTcpEnabled = + Preferences::GetBool("media.peerconnection.ice.tcp", false); + config.mStunClientMaxTransmits = Preferences::GetInt( + "media.peerconnection.ice.stun_client_maximum_transmits", + config.mStunClientMaxTransmits); + config.mTrickleIceGracePeriod = + Preferences::GetInt("media.peerconnection.ice.trickle_grace_period", + config.mTrickleIceGracePeriod); + config.mIceTcpSoSockCount = Preferences::GetInt( + "media.peerconnection.ice.tcp_so_sock_count", config.mIceTcpSoSockCount); + config.mIceTcpListenBacklog = + Preferences::GetInt("media.peerconnection.ice.tcp_listen_backlog", + config.mIceTcpListenBacklog); + (void)Preferences::GetCString("media.peerconnection.ice.force_interface", + config.mForceNetInterface); + return config; +} + +static Maybe<NrIceCtx::NatSimulatorConfig> GetNatConfig() { + bool block_tcp = Preferences::GetBool( + "media.peerconnection.nat_simulator.block_tcp", false); + bool block_udp = Preferences::GetBool( + "media.peerconnection.nat_simulator.block_udp", false); + bool block_tls = Preferences::GetBool( + "media.peerconnection.nat_simulator.block_tls", false); + int error_code_for_drop = Preferences::GetInt( + "media.peerconnection.nat_simulator.error_code_for_drop", 0); + nsAutoCString mapping_type; + (void)Preferences::GetCString( + "media.peerconnection.nat_simulator.mapping_type", mapping_type); + nsAutoCString filtering_type; + (void)Preferences::GetCString( + "media.peerconnection.nat_simulator.filtering_type", filtering_type); + nsAutoCString redirect_address; + (void)Preferences::GetCString( + "media.peerconnection.nat_simulator.redirect_address", redirect_address); + nsAutoCString redirect_targets; + (void)Preferences::GetCString( + "media.peerconnection.nat_simulator.redirect_targets", redirect_targets); + + if (block_udp || block_tcp || block_tls || !mapping_type.IsEmpty() || + !filtering_type.IsEmpty() || !redirect_address.IsEmpty()) { + CSFLogDebug(LOGTAG, "NAT filtering type: %s", filtering_type.get()); + CSFLogDebug(LOGTAG, "NAT mapping type: %s", mapping_type.get()); + NrIceCtx::NatSimulatorConfig natConfig; + natConfig.mBlockUdp = block_udp; + natConfig.mBlockTcp = block_tcp; + natConfig.mBlockTls = block_tls; + natConfig.mErrorCodeForDrop = error_code_for_drop; + natConfig.mFilteringType = filtering_type; + natConfig.mMappingType = mapping_type; + if (redirect_address.Length()) { + CSFLogDebug(LOGTAG, "Redirect address: %s", redirect_address.get()); + CSFLogDebug(LOGTAG, "Redirect targets: %s", redirect_targets.get()); + natConfig.mRedirectAddress = redirect_address; + std::stringstream str(redirect_targets.Data()); + std::string target; + while (getline(str, target, ',')) { + CSFLogDebug(LOGTAG, "Adding target: %s", target.c_str()); + natConfig.mRedirectTargets.AppendElement(target); + } + } + return Some(natConfig); + } + return Nothing(); +} + +void MediaTransportHandlerSTS::CreateIceCtx(const std::string& aName) { + mInitPromise = InvokeAsync( + GetMainThreadSerialEventTarget(), __func__, + [=, self = RefPtr<MediaTransportHandlerSTS>(this)]() { + CSFLogDebug(LOGTAG, "%s starting", __func__); + if (!NSS_IsInitialized()) { + if (NSS_NoDB_Init(nullptr) != SECSuccess) { + MOZ_CRASH(); + return InitPromise::CreateAndReject("NSS_NoDB_Init failed", + __func__); + } + + if (NS_FAILED(mozilla::psm::InitializeCipherSuite())) { + MOZ_CRASH(); + return InitPromise::CreateAndReject("InitializeCipherSuite failed", + __func__); + } + + mozilla::psm::DisableMD5(); + } + + static bool globalInitDone = false; + if (!globalInitDone) { + // Ensure the DNS service is initted for the first time on main + DebugOnly<RefPtr<nsIDNSService>> dnsService = + RefPtr<nsIDNSService>(nsDNSService::GetXPCOMSingleton()); + MOZ_ASSERT(dnsService.value); + mStsThread->Dispatch( + WrapRunnableNM(&NrIceCtx::InitializeGlobals, GetGlobalConfig()), + NS_DISPATCH_NORMAL); + globalInitDone = true; + } + + // Give us a way to globally turn off TURN support + mTurnDisabled = + Preferences::GetBool("media.peerconnection.turn.disable", false); + // We are reading these here, because when we setup the DTLS transport + // we are on the wrong thread to read prefs + mMinDtlsVersion = + Preferences::GetUint("media.peerconnection.dtls.version.min"); + mMaxDtlsVersion = + Preferences::GetUint("media.peerconnection.dtls.version.max"); + mForceNoHost = + Preferences::GetBool("media.peerconnection.ice.no_host", false); + mNatConfig = GetNatConfig(); + + MOZ_RELEASE_ASSERT(STSShutdownHandler::Instance()); + STSShutdownHandler::Instance()->Register(this); + + return InvokeAsync( + mStsThread, __func__, + [=, self = RefPtr<MediaTransportHandlerSTS>(this)]() { + mIceCtx = NrIceCtx::Create(aName); + if (!mIceCtx) { + return InitPromise::CreateAndReject("NrIceCtx::Create failed", + __func__); + } + + mIceCtx->SignalGatheringStateChange.connect( + this, &MediaTransportHandlerSTS::OnGatheringStateChange); + mIceCtx->SignalConnectionStateChange.connect( + this, &MediaTransportHandlerSTS::OnConnectionStateChange); + + mDNSResolver = new NrIceResolver; + nsresult rv; + if (NS_FAILED(rv = mDNSResolver->Init())) { + CSFLogError(LOGTAG, "%s: Failed to initialize dns resolver", + __FUNCTION__); + return InitPromise::CreateAndReject( + "Failed to initialize dns resolver", __func__); + } + if (NS_FAILED(rv = mIceCtx->SetResolver( + mDNSResolver->AllocateResolver()))) { + CSFLogError(LOGTAG, "%s: Failed to get dns resolver", + __FUNCTION__); + return InitPromise::CreateAndReject( + "Failed to get dns resolver", __func__); + } + + CSFLogDebug(LOGTAG, "%s done", __func__); + return InitPromise::CreateAndResolve(true, __func__); + }); + }); +} + +nsresult MediaTransportHandlerSTS::SetIceConfig( + const nsTArray<dom::RTCIceServer>& aIceServers, + dom::RTCIceTransportPolicy aIcePolicy) { + // We rely on getting an error when this happens, so do it up front. + std::vector<NrIceStunServer> stunServers; + std::vector<NrIceTurnServer> turnServers; + nsresult rv = ConvertIceServers(aIceServers, &stunServers, &turnServers); + if (NS_FAILED(rv)) { + return rv; + } + + MOZ_RELEASE_ASSERT(mInitPromise); + + mInitPromise->Then( + mStsThread, __func__, + [=, self = RefPtr<MediaTransportHandlerSTS>(this)]() { + if (!mIceCtx) { + CSFLogError(LOGTAG, "%s: mIceCtx is null", __FUNCTION__); + return; + } + NrIceCtx::Config config; + config.mPolicy = toNrIcePolicy(aIcePolicy); + if (config.mPolicy == NrIceCtx::ICE_POLICY_ALL && mForceNoHost) { + config.mPolicy = NrIceCtx::ICE_POLICY_NO_HOST; + } + config.mNatSimulatorConfig = mNatConfig; + + nsresult rv; + + if (NS_FAILED(rv = mIceCtx->SetStunServers(stunServers))) { + CSFLogError(LOGTAG, "%s: Failed to set stun servers", __FUNCTION__); + return; + } + if (!mTurnDisabled) { + if (NS_FAILED(rv = mIceCtx->SetTurnServers(turnServers))) { + CSFLogError(LOGTAG, "%s: Failed to set turn servers", __FUNCTION__); + return; + } + } else if (!turnServers.empty()) { + CSFLogError(LOGTAG, "%s: Setting turn servers disabled", + __FUNCTION__); + } + if (NS_FAILED(rv = mIceCtx->SetIceConfig(config))) { + CSFLogError(LOGTAG, "%s: Failed to set config", __FUNCTION__); + } + }); + + return NS_OK; +} + +void MediaTransportHandlerSTS::Shutdown() { + CSFLogDebug(LOGTAG, "%s", __func__); + MOZ_ASSERT(NS_IsMainThread()); + mStsThread->Dispatch(NewNonOwningRunnableMethod( + __func__, this, &MediaTransportHandlerSTS::Shutdown_s)); +} + +void MediaTransportHandlerSTS::Shutdown_s() { + CSFLogDebug(LOGTAG, "%s", __func__); + disconnect_all(); + // Clear the transports before destroying the ice ctx so that + // the close_notify alerts have a chance to be sent as the + // TransportFlow destructors execute. + mTransports.clear(); + if (mIceCtx) { + NrIceStats stats = mIceCtx->Destroy(); + CSFLogDebug(LOGTAG, + "Ice Telemetry: stun (retransmits: %d)" + " turn (401s: %d 403s: %d 438s: %d)", + stats.stun_retransmits, stats.turn_401s, stats.turn_403s, + stats.turn_438s); + } + mIceCtx = nullptr; + mDNSResolver = nullptr; +} + +void MediaTransportHandlerSTS::Destroy() { + CSFLogDebug(LOGTAG, "%s %p", __func__, this); + // Our "destruction tour" starts on main, because we need to deregister. + if (!NS_IsMainThread()) { + GetMainThreadSerialEventTarget()->Dispatch( + NewNonOwningRunnableMethod("MediaTransportHandlerSTS::Destroy", this, + &MediaTransportHandlerSTS::Destroy)); + return; + } + + MOZ_ASSERT(NS_IsMainThread()); + if (STSShutdownHandler::Instance()) { + STSShutdownHandler::Instance()->Deregister(this); + Shutdown(); + } + + // mIceCtx still has a reference to us via sigslot! We must dispach to STS, + // and clean up there. However, by the time _that_ happens, we may have + // dispatched a signal callback to mCallbackThread, so we have to dispatch + // the final destruction to mCallbackThread. + nsresult rv = mStsThread->Dispatch( + NewNonOwningRunnableMethod("MediaTransportHandlerSTS::Destroy_s", this, + &MediaTransportHandlerSTS::Destroy_s)); + if (NS_WARN_IF(NS_FAILED(rv))) { + CSFLogError(LOGTAG, + "Unable to dispatch to STS: why has the XPCOM shutdown handler " + "not been invoked?"); + delete this; + } +} + +void MediaTransportHandlerSTS::Destroy_s() { + if (mCallbackThread && !mCallbackThread->IsOnCurrentThread()) { + nsresult rv = mCallbackThread->Dispatch(NewNonOwningRunnableMethod( + __func__, this, &MediaTransportHandlerSTS::DestroyFinal)); + if (NS_SUCCEEDED(rv)) { + return; + } + } + + DestroyFinal(); +} + +void MediaTransportHandlerSTS::DestroyFinal() { delete this; } + +void MediaTransportHandlerSTS::SetProxyConfig( + NrSocketProxyConfig&& aProxyConfig) { + MOZ_RELEASE_ASSERT(mInitPromise); + + mInitPromise->Then( + mStsThread, __func__, + [this, self = RefPtr<MediaTransportHandlerSTS>(this), + aProxyConfig = std::move(aProxyConfig)]() mutable { + if (!mIceCtx) { + return; // Probably due to XPCOM shutdown + } + + mIceCtx->SetProxyConfig(std::move(aProxyConfig)); + }, + [](const std::string& aError) {}); +} + +void MediaTransportHandlerSTS::EnsureProvisionalTransport( + const std::string& aTransportId, const std::string& aUfrag, + const std::string& aPwd, int aComponentCount) { + MOZ_RELEASE_ASSERT(mInitPromise); + + mInitPromise->Then( + mStsThread, __func__, + [=, self = RefPtr<MediaTransportHandlerSTS>(this)]() { + if (!mIceCtx) { + return; // Probably due to XPCOM shutdown + } + + RefPtr<NrIceMediaStream> stream(mIceCtx->GetStream(aTransportId)); + if (!stream) { + CSFLogDebug(LOGTAG, "%s: Creating ICE media stream=%s components=%d", + mIceCtx->name().c_str(), aTransportId.c_str(), + aComponentCount); + + std::ostringstream os; + os << mIceCtx->name() << " transport-id=" << aTransportId; + stream = + mIceCtx->CreateStream(aTransportId, os.str(), aComponentCount); + + if (!stream) { + CSFLogError(LOGTAG, "Failed to create ICE stream."); + return; + } + + stream->SignalCandidate.connect( + this, &MediaTransportHandlerSTS::OnCandidateFound); + } + + // Begins an ICE restart if this stream has a different ufrag/pwd + stream->SetIceCredentials(aUfrag, aPwd); + + // Make sure there's an entry in mTransports + mTransports[aTransportId]; + }, + [](const std::string& aError) {}); +} + +void MediaTransportHandlerSTS::ActivateTransport( + const std::string& aTransportId, const std::string& aLocalUfrag, + const std::string& aLocalPwd, size_t aComponentCount, + const std::string& aUfrag, const std::string& aPassword, + const nsTArray<uint8_t>& aKeyDer, const nsTArray<uint8_t>& aCertDer, + SSLKEAType aAuthType, bool aDtlsClient, const DtlsDigestList& aDigests, + bool aPrivacyRequested) { + MOZ_RELEASE_ASSERT(mInitPromise); + + mInitPromise->Then( + mStsThread, __func__, + [=, keyDer = aKeyDer.Clone(), certDer = aCertDer.Clone(), + self = RefPtr<MediaTransportHandlerSTS>(this)]() { + if (!mIceCtx) { + return; // Probably due to XPCOM shutdown + } + + MOZ_ASSERT(aComponentCount); + RefPtr<DtlsIdentity> dtlsIdentity( + DtlsIdentity::Deserialize(keyDer, certDer, aAuthType)); + if (!dtlsIdentity) { + MOZ_ASSERT(false); + return; + } + + RefPtr<NrIceMediaStream> stream(mIceCtx->GetStream(aTransportId)); + if (!stream) { + MOZ_ASSERT(false); + return; + } + + CSFLogDebug(LOGTAG, "%s: Activating ICE media stream=%s components=%u", + mIceCtx->name().c_str(), aTransportId.c_str(), + static_cast<unsigned>(aComponentCount)); + + std::vector<std::string> attrs; + attrs.reserve(2 /* ufrag + pwd */); + attrs.push_back("ice-ufrag:" + aUfrag); + attrs.push_back("ice-pwd:" + aPassword); + + // If we started an ICE restart in EnsureProvisionalTransport, this is + // where we decide whether to commit or rollback. + nsresult rv = stream->ConnectToPeer(aLocalUfrag, aLocalPwd, attrs); + if (NS_FAILED(rv)) { + CSFLogError(LOGTAG, "Couldn't parse ICE attributes, rv=%u", + static_cast<unsigned>(rv)); + MOZ_ASSERT(false); + return; + } + + Transport transport = mTransports[aTransportId]; + if (!transport.mFlow) { + transport.mFlow = + CreateTransportFlow(aTransportId, false, dtlsIdentity, + aDtlsClient, aDigests, aPrivacyRequested); + if (!transport.mFlow) { + return; + } + TransportLayer* dtls = + transport.mFlow->GetLayer(TransportLayerDtls::ID()); + dtls->SignalStateChange.connect( + this, &MediaTransportHandlerSTS::OnStateChange); + if (aComponentCount < 2) { + dtls->SignalStateChange.connect( + this, &MediaTransportHandlerSTS::OnRtcpStateChange); + } + } + + if (aComponentCount == 2) { + if (!transport.mRtcpFlow) { + transport.mRtcpFlow = + CreateTransportFlow(aTransportId, true, dtlsIdentity, + aDtlsClient, aDigests, aPrivacyRequested); + if (!transport.mRtcpFlow) { + return; + } + TransportLayer* dtls = + transport.mRtcpFlow->GetLayer(TransportLayerDtls::ID()); + dtls->SignalStateChange.connect( + this, &MediaTransportHandlerSTS::OnRtcpStateChange); + } + } else { + transport.mRtcpFlow = nullptr; + // components are 1-indexed + stream->DisableComponent(2); + } + + mTransports[aTransportId] = transport; + }, + [](const std::string& aError) {}); +} + +void MediaTransportHandlerSTS::SetTargetForDefaultLocalAddressLookup( + const std::string& aTargetIp, uint16_t aTargetPort) { + MOZ_RELEASE_ASSERT(mInitPromise); + + mInitPromise->Then( + mStsThread, __func__, + [=, self = RefPtr<MediaTransportHandlerSTS>(this)]() { + if (!mIceCtx) { + return; // Probably due to XPCOM shutdown + } + + mIceCtx->SetTargetForDefaultLocalAddressLookup(aTargetIp, aTargetPort); + }, + [](const std::string& aError) {}); +} + +void MediaTransportHandlerSTS::StartIceGathering( + bool aDefaultRouteOnly, bool aObfuscateHostAddresses, + const nsTArray<NrIceStunAddr>& aStunAddrs) { + MOZ_RELEASE_ASSERT(mInitPromise); + + mInitPromise->Then( + mStsThread, __func__, + [=, stunAddrs = aStunAddrs.Clone(), + self = RefPtr<MediaTransportHandlerSTS>(this)]() { + if (!mIceCtx) { + return; // Probably due to XPCOM shutdown + } + + mObfuscateHostAddresses = aObfuscateHostAddresses; + + // Belt and suspenders - in e10s mode, the call below to SetStunAddrs + // needs to have the proper flags set on ice ctx. For non-e10s, + // setting those flags happens in StartGathering. We could probably + // just set them here, and only do it here. + mIceCtx->SetCtxFlags(aDefaultRouteOnly); + + if (stunAddrs.Length()) { + mIceCtx->SetStunAddrs(stunAddrs); + } + + // Start gathering, but only if there are streams + if (!mIceCtx->GetStreams().empty()) { + mIceCtx->StartGathering(aDefaultRouteOnly, aObfuscateHostAddresses); + } + }, + [](const std::string& aError) {}); +} + +void MediaTransportHandlerSTS::StartIceChecks( + bool aIsControlling, const std::vector<std::string>& aIceOptions) { + MOZ_RELEASE_ASSERT(mInitPromise); + + mInitPromise->Then( + mStsThread, __func__, + [=, self = RefPtr<MediaTransportHandlerSTS>(this)]() { + if (!mIceCtx) { + return; // Probably due to XPCOM shutdown + } + + nsresult rv = mIceCtx->ParseGlobalAttributes(aIceOptions); + if (NS_FAILED(rv)) { + CSFLogError(LOGTAG, "%s: couldn't parse global parameters", + __FUNCTION__); + return; + } + + rv = mIceCtx->SetControlling(aIsControlling ? NrIceCtx::ICE_CONTROLLING + : NrIceCtx::ICE_CONTROLLED); + if (NS_FAILED(rv)) { + CSFLogError(LOGTAG, "%s: couldn't set controlling to %d", + __FUNCTION__, aIsControlling); + return; + } + + rv = mIceCtx->StartChecks(); + if (NS_FAILED(rv)) { + CSFLogError(LOGTAG, "%s: couldn't start checks", __FUNCTION__); + return; + } + }, + [](const std::string& aError) {}); +} + +void TokenizeCandidate(const std::string& aCandidate, + std::vector<std::string>& aTokens) { + aTokens.clear(); + + std::istringstream iss(aCandidate); + std::string token; + while (std::getline(iss, token, ' ')) { + aTokens.push_back(token); + } +} + +void MediaTransportHandlerSTS::AddIceCandidate( + const std::string& aTransportId, const std::string& aCandidate, + const std::string& aUfrag, const std::string& aObfuscatedAddress) { + MOZ_RELEASE_ASSERT(mInitPromise); + + mInitPromise->Then( + mStsThread, __func__, + [=, self = RefPtr<MediaTransportHandlerSTS>(this)]() { + if (!mIceCtx) { + return; // Probably due to XPCOM shutdown + } + + std::vector<std::string> tokens; + TokenizeCandidate(aCandidate, tokens); + + RefPtr<NrIceMediaStream> stream(mIceCtx->GetStream(aTransportId)); + if (!stream) { + CSFLogError(LOGTAG, + "No ICE stream for candidate with transport id %s: %s", + aTransportId.c_str(), aCandidate.c_str()); + return; + } + + nsresult rv = stream->ParseTrickleCandidate(aCandidate, aUfrag, + aObfuscatedAddress); + if (NS_SUCCEEDED(rv)) { + // If the address is not obfuscated, we want to track it as + // explicitly signaled so that we know it is fine to reveal + // the address later on. + if (mObfuscateHostAddresses && tokens.size() > 4 && + aObfuscatedAddress.empty()) { + mSignaledAddresses.insert(tokens[4]); + } + } else { + CSFLogError(LOGTAG, + "Couldn't process ICE candidate with transport id %s: " + "%s", + aTransportId.c_str(), aCandidate.c_str()); + } + }, + [](const std::string& aError) {}); +} + +void MediaTransportHandlerSTS::UpdateNetworkState(bool aOnline) { + MOZ_RELEASE_ASSERT(mInitPromise); + + mInitPromise->Then( + mStsThread, __func__, + [=, self = RefPtr<MediaTransportHandlerSTS>(this)]() { + if (!mIceCtx) { + return; // Probably due to XPCOM shutdown + } + + mIceCtx->UpdateNetworkState(aOnline); + }, + [](const std::string& aError) {}); +} + +void MediaTransportHandlerSTS::RemoveTransportsExcept( + const std::set<std::string>& aTransportIds) { + MOZ_RELEASE_ASSERT(mInitPromise); + + mInitPromise->Then( + mStsThread, __func__, + [=, self = RefPtr<MediaTransportHandlerSTS>(this)]() { + if (!mIceCtx) { + return; // Probably due to XPCOM shutdown + } + + for (auto it = mTransports.begin(); it != mTransports.end();) { + const std::string transportId(it->first); + if (!aTransportIds.count(transportId)) { + if (it->second.mFlow) { + OnStateChange(transportId, TransportLayer::TS_NONE); + OnRtcpStateChange(transportId, TransportLayer::TS_NONE); + } + // Erase the transport before destroying the ice stream so that + // the close_notify alerts have a chance to be sent as the + // TransportFlow destructors execute. + it = mTransports.erase(it); + // We're already on the STS thread, but the TransportFlow + // destructor executed when mTransports.erase(it) is called + // above dispatches the call to DestroyFinal to the STS thread. If + // we don't also dispatch the call to destroy the NrIceMediaStream + // to the STS thread, it will tear down the NrIceMediaStream + // before the TransportFlow is destroyed. Without a valid + // NrIceMediaStream the close_notify alert cannot be sent. + mStsThread->Dispatch(NS_NewRunnableFunction( + __func__, [iceCtx = RefPtr<NrIceCtx>(mIceCtx), transportId] { + iceCtx->DestroyStream(transportId); + })); + } else { + MOZ_ASSERT(it->second.mFlow); + ++it; + } + } + }, + [](const std::string& aError) {}); +} + +void MediaTransportHandlerSTS::SendPacket(const std::string& aTransportId, + MediaPacket&& aPacket) { + MOZ_RELEASE_ASSERT(mInitPromise); + + mInitPromise->Then( + mStsThread, __func__, + [this, self = RefPtr<MediaTransportHandlerSTS>(this), aTransportId, + aPacket = std::move(aPacket)]() mutable { + if (!mIceCtx) { + return; // Probably due to XPCOM shutdown + } + + MOZ_ASSERT(aPacket.type() != MediaPacket::UNCLASSIFIED); + RefPtr<TransportFlow> flow = + GetTransportFlow(aTransportId, aPacket.type() == MediaPacket::RTCP); + + if (!flow) { + CSFLogError(LOGTAG, + "%s: No such transport flow (%s) for outgoing packet", + mIceCtx->name().c_str(), aTransportId.c_str()); + return; + } + + TransportLayer* layer = nullptr; + switch (aPacket.type()) { + case MediaPacket::SCTP: + layer = flow->GetLayer(TransportLayerDtls::ID()); + break; + case MediaPacket::RTP: + case MediaPacket::RTCP: + layer = flow->GetLayer(TransportLayerSrtp::ID()); + break; + default: + // Maybe it would be useful to allow the injection of other packet + // types for testing? + MOZ_ASSERT(false); + return; + } + + MOZ_ASSERT(layer); + + if (layer->SendPacket(aPacket) < 0) { + CSFLogError(LOGTAG, "%s: Transport flow (%s) failed to send packet", + mIceCtx->name().c_str(), aTransportId.c_str()); + } + }, + [](const std::string& aError) {}); +} + +TransportLayer::State MediaTransportHandler::GetState( + const std::string& aTransportId, bool aRtcp) const { + // TODO Bug 1520692: we should allow Datachannel to connect without + // DTLS SRTP keys + if (mCallbackThread) { + MOZ_ASSERT(mCallbackThread->IsOnCurrentThread()); + } + + const std::map<std::string, TransportLayer::State>* cache = nullptr; + if (aRtcp) { + cache = &mRtcpStateCache; + } else { + cache = &mStateCache; + } + + auto it = cache->find(aTransportId); + if (it != cache->end()) { + return it->second; + } + return TransportLayer::TS_NONE; +} + +void MediaTransportHandler::OnCandidate(const std::string& aTransportId, + const CandidateInfo& aCandidateInfo) { + if (mCallbackThread && !mCallbackThread->IsOnCurrentThread()) { + mCallbackThread->Dispatch( + // This is being called from sigslot, which does not hold a strong ref. + WrapRunnable(this, &MediaTransportHandler::OnCandidate, aTransportId, + aCandidateInfo), + NS_DISPATCH_NORMAL); + return; + } + + SignalCandidate(aTransportId, aCandidateInfo); +} + +void MediaTransportHandler::OnAlpnNegotiated(const std::string& aAlpn) { + if (mCallbackThread && !mCallbackThread->IsOnCurrentThread()) { + mCallbackThread->Dispatch( + // This is being called from sigslot, which does not hold a strong ref. + WrapRunnable(this, &MediaTransportHandler::OnAlpnNegotiated, aAlpn), + NS_DISPATCH_NORMAL); + return; + } + + const bool privacyRequested = aAlpn == "c-webrtc"; + SignalAlpnNegotiated(aAlpn, privacyRequested); +} + +void MediaTransportHandler::OnGatheringStateChange( + dom::RTCIceGatheringState aState) { + if (mCallbackThread && !mCallbackThread->IsOnCurrentThread()) { + mCallbackThread->Dispatch( + // This is being called from sigslot, which does not hold a strong ref. + WrapRunnable(this, &MediaTransportHandler::OnGatheringStateChange, + aState), + NS_DISPATCH_NORMAL); + return; + } + + SignalGatheringStateChange(aState); +} + +void MediaTransportHandler::OnConnectionStateChange( + dom::RTCIceConnectionState aState) { + if (mCallbackThread && !mCallbackThread->IsOnCurrentThread()) { + mCallbackThread->Dispatch( + // This is being called from sigslot, which does not hold a strong ref. + WrapRunnable(this, &MediaTransportHandler::OnConnectionStateChange, + aState), + NS_DISPATCH_NORMAL); + return; + } + + SignalConnectionStateChange(aState); +} + +void MediaTransportHandler::OnPacketReceived(const std::string& aTransportId, + const MediaPacket& aPacket) { + if (mCallbackThread && !mCallbackThread->IsOnCurrentThread()) { + mCallbackThread->Dispatch( + // This is being called from sigslot, which does not hold a strong ref. + WrapRunnable(this, &MediaTransportHandler::OnPacketReceived, + aTransportId, aPacket.Clone()), + NS_DISPATCH_NORMAL); + return; + } + + SignalPacketReceived(aTransportId, aPacket); +} + +void MediaTransportHandler::OnEncryptedSending(const std::string& aTransportId, + const MediaPacket& aPacket) { + if (mCallbackThread && !mCallbackThread->IsOnCurrentThread()) { + mCallbackThread->Dispatch( + // This is being called from sigslot, which does not hold a strong ref. + WrapRunnable(this, &MediaTransportHandler::OnEncryptedSending, + aTransportId, aPacket.Clone()), + NS_DISPATCH_NORMAL); + return; + } + + SignalEncryptedSending(aTransportId, aPacket); +} + +void MediaTransportHandler::OnStateChange(const std::string& aTransportId, + TransportLayer::State aState) { + if (mCallbackThread && !mCallbackThread->IsOnCurrentThread()) { + mCallbackThread->Dispatch( + // This is being called from sigslot, which does not hold a strong ref. + WrapRunnable(this, &MediaTransportHandler::OnStateChange, aTransportId, + aState), + NS_DISPATCH_NORMAL); + return; + } + + if (aState == TransportLayer::TS_NONE) { + mStateCache.erase(aTransportId); + } else { + mStateCache[aTransportId] = aState; + } + SignalStateChange(aTransportId, aState); +} + +void MediaTransportHandler::OnRtcpStateChange(const std::string& aTransportId, + TransportLayer::State aState) { + if (mCallbackThread && !mCallbackThread->IsOnCurrentThread()) { + mCallbackThread->Dispatch( + // This is being called from sigslot, which does not hold a strong ref. + WrapRunnable(this, &MediaTransportHandler::OnRtcpStateChange, + aTransportId, aState), + NS_DISPATCH_NORMAL); + return; + } + + if (aState == TransportLayer::TS_NONE) { + mRtcpStateCache.erase(aTransportId); + } else { + mRtcpStateCache[aTransportId] = aState; + } + SignalRtcpStateChange(aTransportId, aState); +} + +RefPtr<dom::RTCStatsPromise> MediaTransportHandlerSTS::GetIceStats( + const std::string& aTransportId, DOMHighResTimeStamp aNow) { + MOZ_RELEASE_ASSERT(mInitPromise); + + return mInitPromise->Then(mStsThread, __func__, [=, self = RefPtr(this)]() { + UniquePtr<dom::RTCStatsCollection> stats(new dom::RTCStatsCollection); + if (mIceCtx) { + for (const auto& stream : mIceCtx->GetStreams()) { + if (aTransportId.empty() || aTransportId == stream->GetId()) { + GetIceStats(*stream, aNow, stats.get()); + } + } + } + return dom::RTCStatsPromise::CreateAndResolve(std::move(stats), __func__); + }); +} + +RefPtr<MediaTransportHandler::IceLogPromise> +MediaTransportHandlerSTS::GetIceLog(const nsCString& aPattern) { + return InvokeAsync( + mStsThread, __func__, [=, self = RefPtr<MediaTransportHandlerSTS>(this)] { + dom::Sequence<nsString> converted; + RLogConnector* logs = RLogConnector::GetInstance(); + std::deque<std::string> result; + // Might not exist yet. + if (logs) { + logs->Filter(aPattern.get(), 0, &result); + } + /// XXX(Bug 1631386) Check if we should reject the promise instead of + /// crashing in an OOM situation. + if (!converted.SetCapacity(result.size(), fallible)) { + mozalloc_handle_oom(sizeof(nsString) * result.size()); + } + for (auto& line : result) { + // Cannot fail, SetCapacity was called before. + (void)converted.AppendElement(NS_ConvertUTF8toUTF16(line.c_str()), + fallible); + } + return IceLogPromise::CreateAndResolve(std::move(converted), __func__); + }); +} + +void MediaTransportHandlerSTS::ClearIceLog() { + if (!mStsThread->IsOnCurrentThread()) { + mStsThread->Dispatch(WrapRunnable(RefPtr<MediaTransportHandlerSTS>(this), + &MediaTransportHandlerSTS::ClearIceLog), + NS_DISPATCH_NORMAL); + return; + } + + RLogConnector* logs = RLogConnector::GetInstance(); + if (logs) { + logs->Clear(); + } +} + +void MediaTransportHandlerSTS::EnterPrivateMode() { + if (!mStsThread->IsOnCurrentThread()) { + mStsThread->Dispatch( + WrapRunnable(RefPtr<MediaTransportHandlerSTS>(this), + &MediaTransportHandlerSTS::EnterPrivateMode), + NS_DISPATCH_NORMAL); + return; + } + + RLogConnector::GetInstance()->EnterPrivateMode(); +} + +void MediaTransportHandlerSTS::ExitPrivateMode() { + if (!mStsThread->IsOnCurrentThread()) { + mStsThread->Dispatch( + WrapRunnable(RefPtr<MediaTransportHandlerSTS>(this), + &MediaTransportHandlerSTS::ExitPrivateMode), + NS_DISPATCH_NORMAL); + return; + } + + auto* log = RLogConnector::GetInstance(); + MOZ_ASSERT(log); + if (log) { + log->ExitPrivateMode(); + } +} + +static void ToRTCIceCandidateStats( + const std::vector<NrIceCandidate>& candidates, + dom::RTCStatsType candidateType, const nsString& transportId, + DOMHighResTimeStamp now, dom::RTCStatsCollection* stats, + bool obfuscateHostAddresses, + const std::set<std::string>& signaledAddresses) { + MOZ_ASSERT(stats); + for (const auto& candidate : candidates) { + dom::RTCIceCandidateStats cand; + cand.mType.Construct(candidateType); + NS_ConvertASCIItoUTF16 codeword(candidate.codeword.c_str()); + cand.mTransportId.Construct(transportId); + cand.mId.Construct(codeword); + cand.mTimestamp.Construct(now); + cand.mCandidateType.Construct(dom::RTCIceCandidateType(candidate.type)); + cand.mPriority.Construct(candidate.priority); + // https://tools.ietf.org/html/draft-ietf-rtcweb-mdns-ice-candidates-03#section-3.3.1 + // This obfuscates the address with the mDNS address if one exists + if (!candidate.mdns_addr.empty()) { + cand.mAddress.Construct( + NS_ConvertASCIItoUTF16(candidate.mdns_addr.c_str())); + } else if (obfuscateHostAddresses && + candidate.type == NrIceCandidate::ICE_PEER_REFLEXIVE && + signaledAddresses.find(candidate.cand_addr.host) == + signaledAddresses.end()) { + cand.mAddress.Construct(NS_ConvertASCIItoUTF16("(redacted)")); + } else { + cand.mAddress.Construct( + NS_ConvertASCIItoUTF16(candidate.cand_addr.host.c_str())); + } + cand.mPort.Construct(candidate.cand_addr.port); + cand.mProtocol.Construct( + NS_ConvertASCIItoUTF16(candidate.cand_addr.transport.c_str())); + if (candidateType == dom::RTCStatsType::Local_candidate && + dom::RTCIceCandidateType(candidate.type) == + dom::RTCIceCandidateType::Relay) { + cand.mRelayProtocol.Construct( + NS_ConvertASCIItoUTF16(candidate.local_addr.transport.c_str())); + } + cand.mProxied.Construct(NS_ConvertASCIItoUTF16( + candidate.is_proxied ? "proxied" : "non-proxied")); + if (!stats->mIceCandidateStats.AppendElement(cand, 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 (candidate.trickled) { + if (!stats->mTrickledIceCandidateStats.AppendElement(cand, fallible)) { + mozalloc_handle_oom(0); + } + } + } +} + +void MediaTransportHandlerSTS::GetIceStats( + const NrIceMediaStream& aStream, DOMHighResTimeStamp aNow, + dom::RTCStatsCollection* aStats) const { + MOZ_ASSERT(mStsThread->IsOnCurrentThread()); + + NS_ConvertASCIItoUTF16 transportId(aStream.GetId().c_str()); + + std::vector<NrIceCandidatePair> candPairs; + nsresult res = aStream.GetCandidatePairs(&candPairs); + if (NS_FAILED(res)) { + CSFLogError(LOGTAG, + "%s: Error getting candidate pairs for transport id \"%s\"", + __FUNCTION__, aStream.GetId().c_str()); + return; + } + + for (auto& candPair : candPairs) { + NS_ConvertASCIItoUTF16 codeword(candPair.codeword.c_str()); + NS_ConvertASCIItoUTF16 localCodeword(candPair.local.codeword.c_str()); + NS_ConvertASCIItoUTF16 remoteCodeword(candPair.remote.codeword.c_str()); + // Only expose candidate-pair statistics to chrome, until we've thought + // through the implications of exposing it to content. + + dom::RTCIceCandidatePairStats s; + s.mId.Construct(codeword); + s.mTransportId.Construct(transportId); + s.mTimestamp.Construct(aNow); + s.mType.Construct(dom::RTCStatsType::Candidate_pair); + s.mLocalCandidateId.Construct(localCodeword); + s.mRemoteCandidateId.Construct(remoteCodeword); + s.mNominated.Construct(candPair.nominated); + s.mWritable.Construct(candPair.writable); + s.mReadable.Construct(candPair.readable); + s.mPriority.Construct(candPair.priority); + s.mSelected.Construct(candPair.selected); + s.mBytesSent.Construct(candPair.bytes_sent); + s.mBytesReceived.Construct(candPair.bytes_recvd); + s.mLastPacketSentTimestamp.Construct(candPair.ms_since_last_send); + s.mLastPacketReceivedTimestamp.Construct(candPair.ms_since_last_recv); + s.mState.Construct(dom::RTCStatsIceCandidatePairState(candPair.state)); + s.mComponentId.Construct(candPair.component_id); + if (!aStats->mIceCandidatePairStats.AppendElement(s, 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); + } + } + + std::vector<NrIceCandidate> candidates; + if (NS_SUCCEEDED(aStream.GetLocalCandidates(&candidates))) { + ToRTCIceCandidateStats(candidates, dom::RTCStatsType::Local_candidate, + transportId, aNow, aStats, mObfuscateHostAddresses, + mSignaledAddresses); + // add the local candidates unparsed string to a sequence + for (const auto& candidate : candidates) { + if (!aStats->mRawLocalCandidates.AppendElement( + NS_ConvertASCIItoUTF16(candidate.label.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); + } + } + } + candidates.clear(); + + if (NS_SUCCEEDED(aStream.GetRemoteCandidates(&candidates))) { + ToRTCIceCandidateStats(candidates, dom::RTCStatsType::Remote_candidate, + transportId, aNow, aStats, mObfuscateHostAddresses, + mSignaledAddresses); + // add the remote candidates unparsed string to a sequence + for (const auto& candidate : candidates) { + if (!aStats->mRawRemoteCandidates.AppendElement( + NS_ConvertASCIItoUTF16(candidate.label.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); + } + } + } +} + +RefPtr<TransportFlow> MediaTransportHandlerSTS::GetTransportFlow( + const std::string& aTransportId, bool aIsRtcp) const { + auto it = mTransports.find(aTransportId); + if (it == mTransports.end()) { + return nullptr; + } + + if (aIsRtcp) { + return it->second.mRtcpFlow ? it->second.mRtcpFlow : it->second.mFlow; + ; + } + + return it->second.mFlow; +} + +RefPtr<TransportFlow> MediaTransportHandlerSTS::CreateTransportFlow( + const std::string& aTransportId, bool aIsRtcp, + const RefPtr<DtlsIdentity>& aDtlsIdentity, bool aDtlsClient, + const DtlsDigestList& aDigests, bool aPrivacyRequested) { + nsresult rv; + RefPtr<TransportFlow> flow = new TransportFlow(aTransportId); + + // The media streams are made on STS so we need to defer setup. + auto ice = MakeUnique<TransportLayerIce>(); + auto dtls = MakeUnique<TransportLayerDtls>(); + auto srtp = MakeUnique<TransportLayerSrtp>(*dtls); + dtls->SetRole(aDtlsClient ? TransportLayerDtls::CLIENT + : TransportLayerDtls::SERVER); + + dtls->SetIdentity(aDtlsIdentity); + + dtls->SetMinMaxVersion( + static_cast<TransportLayerDtls::Version>(mMinDtlsVersion), + static_cast<TransportLayerDtls::Version>(mMaxDtlsVersion)); + + for (const auto& digest : aDigests) { + rv = dtls->SetVerificationDigest(digest); + if (NS_FAILED(rv)) { + CSFLogError(LOGTAG, "Could not set fingerprint"); + return nullptr; + } + } + + std::vector<uint16_t> srtpCiphers = + TransportLayerDtls::GetDefaultSrtpCiphers(); + + rv = dtls->SetSrtpCiphers(srtpCiphers); + if (NS_FAILED(rv)) { + CSFLogError(LOGTAG, "Couldn't set SRTP ciphers"); + return nullptr; + } + + // Always permits negotiation of the confidential mode. + // Only allow non-confidential (which is an allowed default), + // if we aren't confidential. + std::set<std::string> alpn = {"c-webrtc"}; + std::string alpnDefault; + if (!aPrivacyRequested) { + alpnDefault = "webrtc"; + alpn.insert(alpnDefault); + } + rv = dtls->SetAlpn(alpn, alpnDefault); + if (NS_FAILED(rv)) { + CSFLogError(LOGTAG, "Couldn't set ALPN"); + return nullptr; + } + + ice->SetParameters(mIceCtx->GetStream(aTransportId), aIsRtcp ? 2 : 1); + NS_ENSURE_SUCCESS(ice->Init(), nullptr); + NS_ENSURE_SUCCESS(dtls->Init(), nullptr); + NS_ENSURE_SUCCESS(srtp->Init(), nullptr); + dtls->Chain(ice.get()); + srtp->Chain(ice.get()); + + dtls->SignalPacketReceived.connect(this, + &MediaTransportHandlerSTS::PacketReceived); + srtp->SignalPacketReceived.connect(this, + &MediaTransportHandlerSTS::PacketReceived); + ice->SignalPacketSending.connect( + this, &MediaTransportHandlerSTS::EncryptedPacketSending); + flow->PushLayer(ice.release()); + flow->PushLayer(dtls.release()); + flow->PushLayer(srtp.release()); + return flow; +} + +static mozilla::dom::RTCIceGatheringState toDomIceGatheringState( + NrIceCtx::GatheringState aState) { + switch (aState) { + case NrIceCtx::ICE_CTX_GATHER_INIT: + return dom::RTCIceGatheringState::New; + case NrIceCtx::ICE_CTX_GATHER_STARTED: + return dom::RTCIceGatheringState::Gathering; + case NrIceCtx::ICE_CTX_GATHER_COMPLETE: + return dom::RTCIceGatheringState::Complete; + } + MOZ_CRASH(); +} + +void MediaTransportHandlerSTS::OnGatheringStateChange( + NrIceCtx* aIceCtx, NrIceCtx::GatheringState aState) { + OnGatheringStateChange(toDomIceGatheringState(aState)); +} + +static mozilla::dom::RTCIceConnectionState toDomIceConnectionState( + NrIceCtx::ConnectionState aState) { + switch (aState) { + case NrIceCtx::ICE_CTX_INIT: + return dom::RTCIceConnectionState::New; + case NrIceCtx::ICE_CTX_CHECKING: + return dom::RTCIceConnectionState::Checking; + case NrIceCtx::ICE_CTX_CONNECTED: + return dom::RTCIceConnectionState::Connected; + case NrIceCtx::ICE_CTX_COMPLETED: + return dom::RTCIceConnectionState::Completed; + case NrIceCtx::ICE_CTX_FAILED: + return dom::RTCIceConnectionState::Failed; + case NrIceCtx::ICE_CTX_DISCONNECTED: + return dom::RTCIceConnectionState::Disconnected; + case NrIceCtx::ICE_CTX_CLOSED: + return dom::RTCIceConnectionState::Closed; + } + MOZ_CRASH(); +} + +void MediaTransportHandlerSTS::OnConnectionStateChange( + NrIceCtx* aIceCtx, NrIceCtx::ConnectionState aState) { + OnConnectionStateChange(toDomIceConnectionState(aState)); +} + +// The stuff below here will eventually go into the MediaTransportChild class +void MediaTransportHandlerSTS::OnCandidateFound( + NrIceMediaStream* aStream, const std::string& aCandidate, + const std::string& aUfrag, const std::string& aMDNSAddr, + const std::string& aActualAddr) { + CandidateInfo info; + info.mCandidate = aCandidate; + MOZ_ASSERT(!aUfrag.empty()); + info.mUfrag = aUfrag; + NrIceCandidate defaultRtpCandidate; + NrIceCandidate defaultRtcpCandidate; + nsresult rv = aStream->GetDefaultCandidate(1, &defaultRtpCandidate); + if (NS_SUCCEEDED(rv)) { + if (!defaultRtpCandidate.mdns_addr.empty()) { + info.mDefaultHostRtp = "0.0.0.0"; + info.mDefaultPortRtp = 9; + } else { + info.mDefaultHostRtp = defaultRtpCandidate.cand_addr.host; + info.mDefaultPortRtp = defaultRtpCandidate.cand_addr.port; + } + } else { + CSFLogError(LOGTAG, + "%s: GetDefaultCandidates failed for transport id %s, " + "res=%u", + __FUNCTION__, aStream->GetId().c_str(), + static_cast<unsigned>(rv)); + } + + // Optional; component won't exist if doing rtcp-mux + if (NS_SUCCEEDED(aStream->GetDefaultCandidate(2, &defaultRtcpCandidate))) { + if (!defaultRtcpCandidate.mdns_addr.empty()) { + info.mDefaultHostRtcp = defaultRtcpCandidate.mdns_addr; + } else { + info.mDefaultHostRtcp = defaultRtcpCandidate.cand_addr.host; + } + info.mDefaultPortRtcp = defaultRtcpCandidate.cand_addr.port; + } + + info.mMDNSAddress = aMDNSAddr; + info.mActualAddress = aActualAddr; + + OnCandidate(aStream->GetId(), info); +} + +void MediaTransportHandlerSTS::OnStateChange(TransportLayer* aLayer, + TransportLayer::State aState) { + if (aState == TransportLayer::TS_OPEN) { + MOZ_ASSERT(aLayer->id() == TransportLayerDtls::ID()); + TransportLayerDtls* dtlsLayer = static_cast<TransportLayerDtls*>(aLayer); + OnAlpnNegotiated(dtlsLayer->GetNegotiatedAlpn()); + } + + // DTLS state indicates the readiness of the transport as a whole, because + // SRTP uses the keys from the DTLS handshake. + MediaTransportHandler::OnStateChange(aLayer->flow_id(), aState); +} + +void MediaTransportHandlerSTS::OnRtcpStateChange(TransportLayer* aLayer, + TransportLayer::State aState) { + MediaTransportHandler::OnRtcpStateChange(aLayer->flow_id(), aState); +} + +constexpr static const char* PacketTypeToString(MediaPacket::Type type) { + switch (type) { + case MediaPacket::Type::UNCLASSIFIED: + return "UNCLASSIFIED"; + case MediaPacket::Type::SRTP: + return "SRTP"; + case MediaPacket::Type::SRTCP: + return "SRTCP"; + case MediaPacket::Type::DTLS: + return "DTLS"; + case MediaPacket::Type::RTP: + return "RTP"; + case MediaPacket::Type::RTCP: + return "RTCP"; + case MediaPacket::Type::SCTP: + return "SCTP"; + default: + MOZ_ASSERT(false, "unreached"); + return ""; + } +} + +void MediaTransportHandlerSTS::PacketReceived(TransportLayer* aLayer, + MediaPacket& aPacket) { + MEDIA_TRANSPORT_HANDLER_PACKET_RECEIVED(aPacket); + OnPacketReceived(aLayer->flow_id(), aPacket); +} + +void MediaTransportHandlerSTS::EncryptedPacketSending(TransportLayer* aLayer, + MediaPacket& aPacket) { + OnEncryptedSending(aLayer->flow_id(), aPacket); +} + +} // namespace mozilla + +#undef MEDIA_TRANSPORT_HANDLER_PACKET_RECEIVED diff --git a/dom/media/webrtc/jsapi/MediaTransportHandler.h b/dom/media/webrtc/jsapi/MediaTransportHandler.h new file mode 100644 index 0000000000..a776cb6fd7 --- /dev/null +++ b/dom/media/webrtc/jsapi/MediaTransportHandler.h @@ -0,0 +1,167 @@ +/* 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/. */ + +#ifndef _MTRANSPORTHANDLER_H__ +#define _MTRANSPORTHANDLER_H__ + +#include "mozilla/RefPtr.h" +#include "nsISupportsImpl.h" +#include "transport/sigslot.h" +#include "transport/transportlayer.h" // Need the State enum +#include "transport/dtlsidentity.h" // For DtlsDigest +#include "mozilla/dom/RTCPeerConnectionBinding.h" +#include "mozilla/dom/RTCConfigurationBinding.h" +#include "transport/nricectx.h" // Need some enums +#include "common/CandidateInfo.h" +#include "transport/nr_socket_proxy_config.h" +#include "RTCStatsReport.h" + +#include "nsString.h" + +#include <string> +#include <set> +#include <vector> + +namespace mozilla { +class DtlsIdentity; +class NrIceCtx; +class NrIceMediaStream; +class NrIceResolver; +class TransportFlow; +class RTCStatsQuery; + +namespace dom { +struct RTCStatsReportInternal; +} + +class MediaTransportHandler { + public: + // Creates either a MediaTransportHandlerSTS or a MediaTransportHandlerIPC, + // as appropriate. If you want signals to fire on a specific thread, pass + // the event target here, otherwise they will fire on whatever is convenient. + // Note: This also determines what thread the state cache is updated on! + // Don't call GetState on any other thread! + static already_AddRefed<MediaTransportHandler> Create( + nsISerialEventTarget* aCallbackThread); + + explicit MediaTransportHandler(nsISerialEventTarget* aCallbackThread) + : mCallbackThread(aCallbackThread) {} + + // Exposed so we can synchronously validate ICE servers from PeerConnection + static nsresult ConvertIceServers( + const nsTArray<dom::RTCIceServer>& aIceServers, + std::vector<NrIceStunServer>* aStunServers, + std::vector<NrIceTurnServer>* aTurnServers); + + typedef MozPromise<dom::Sequence<nsString>, nsresult, true> IceLogPromise; + + virtual void Initialize() {} + + // There's a wrinkle here; the ICE logging is not separated out by + // MediaTransportHandler. These are a little more like static methods, but + // to avoid needing yet another IPC interface, we bolt them on here. + virtual RefPtr<IceLogPromise> GetIceLog(const nsCString& aPattern) = 0; + virtual void ClearIceLog() = 0; + virtual void EnterPrivateMode() = 0; + virtual void ExitPrivateMode() = 0; + + virtual void CreateIceCtx(const std::string& aName) = 0; + + virtual nsresult SetIceConfig(const nsTArray<dom::RTCIceServer>& aIceServers, + dom::RTCIceTransportPolicy aIcePolicy) = 0; + + // We will probably be able to move the proxy lookup stuff into + // this class once we move mtransport to its own process. + virtual void SetProxyConfig(NrSocketProxyConfig&& aProxyConfig) = 0; + + virtual void EnsureProvisionalTransport(const std::string& aTransportId, + const std::string& aLocalUfrag, + const std::string& aLocalPwd, + int aComponentCount) = 0; + + virtual void SetTargetForDefaultLocalAddressLookup( + const std::string& aTargetIp, uint16_t aTargetPort) = 0; + + // We set default-route-only as late as possible because it depends on what + // capture permissions have been granted on the window, which could easily + // change between Init (ie; when the PC is created) and StartIceGathering + // (ie; when we set the local description). + virtual void StartIceGathering(bool aDefaultRouteOnly, + bool aObfuscateHostAddresses, + // TODO: It probably makes sense to look + // this up internally + const nsTArray<NrIceStunAddr>& aStunAddrs) = 0; + + virtual void ActivateTransport( + const std::string& aTransportId, const std::string& aLocalUfrag, + const std::string& aLocalPwd, size_t aComponentCount, + const std::string& aUfrag, const std::string& aPassword, + const nsTArray<uint8_t>& aKeyDer, const nsTArray<uint8_t>& aCertDer, + SSLKEAType aAuthType, bool aDtlsClient, const DtlsDigestList& aDigests, + bool aPrivacyRequested) = 0; + + virtual void RemoveTransportsExcept( + const std::set<std::string>& aTransportIds) = 0; + + virtual void StartIceChecks(bool aIsControlling, + const std::vector<std::string>& aIceOptions) = 0; + + virtual void SendPacket(const std::string& aTransportId, + MediaPacket&& aPacket) = 0; + + virtual void AddIceCandidate(const std::string& aTransportId, + const std::string& aCandidate, + const std::string& aUFrag, + const std::string& aObfuscatedAddress) = 0; + + virtual void UpdateNetworkState(bool aOnline) = 0; + + virtual RefPtr<dom::RTCStatsPromise> GetIceStats( + const std::string& aTransportId, DOMHighResTimeStamp aNow) = 0; + + sigslot::signal2<const std::string&, const CandidateInfo&> SignalCandidate; + sigslot::signal2<const std::string&, bool> SignalAlpnNegotiated; + sigslot::signal1<dom::RTCIceGatheringState> SignalGatheringStateChange; + sigslot::signal1<dom::RTCIceConnectionState> SignalConnectionStateChange; + + sigslot::signal2<const std::string&, const MediaPacket&> SignalPacketReceived; + sigslot::signal2<const std::string&, const MediaPacket&> + SignalEncryptedSending; + sigslot::signal2<const std::string&, TransportLayer::State> SignalStateChange; + sigslot::signal2<const std::string&, TransportLayer::State> + SignalRtcpStateChange; + + NS_INLINE_DECL_THREADSAFE_REFCOUNTING_WITH_DESTROY(MediaTransportHandler, + Destroy()) + + TransportLayer::State GetState(const std::string& aTransportId, + bool aRtcp) const; + + protected: + void OnCandidate(const std::string& aTransportId, + const CandidateInfo& aCandidateInfo); + void OnAlpnNegotiated(const std::string& aAlpn); + void OnGatheringStateChange(dom::RTCIceGatheringState aState); + void OnConnectionStateChange(dom::RTCIceConnectionState aState); + void OnPacketReceived(const std::string& aTransportId, + const MediaPacket& aPacket); + void OnEncryptedSending(const std::string& aTransportId, + const MediaPacket& aPacket); + void OnStateChange(const std::string& aTransportId, + TransportLayer::State aState); + void OnRtcpStateChange(const std::string& aTransportId, + TransportLayer::State aState); + virtual void Destroy() = 0; + virtual ~MediaTransportHandler() = default; + std::map<std::string, TransportLayer::State> mStateCache; + std::map<std::string, TransportLayer::State> mRtcpStateCache; + RefPtr<nsISerialEventTarget> mCallbackThread; +}; + +void TokenizeCandidate(const std::string& aCandidate, + std::vector<std::string>& aTokens); + +} // namespace mozilla + +#endif //_MTRANSPORTHANDLER_H__ diff --git a/dom/media/webrtc/jsapi/MediaTransportHandlerIPC.cpp b/dom/media/webrtc/jsapi/MediaTransportHandlerIPC.cpp new file mode 100644 index 0000000000..6369d229ee --- /dev/null +++ b/dom/media/webrtc/jsapi/MediaTransportHandlerIPC.cpp @@ -0,0 +1,414 @@ +/* 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 "MediaTransportHandlerIPC.h" +#include "mozilla/dom/MediaTransportChild.h" +#include "nsThreadUtils.h" +#include "mozilla/net/SocketProcessBridgeChild.h" +#include "mozilla/RefPtr.h" +#include "mozilla/ipc/BackgroundChild.h" +#include "mozilla/ipc/PBackgroundChild.h" +#include "common/browser_logging/CSFLog.h" + +namespace mozilla { + +static const char* mthipcLogTag = "MediaTransportHandler"; +#ifdef LOGTAG +# undef LOGTAG +#endif +#define LOGTAG mthipcLogTag + +MediaTransportHandlerIPC::MediaTransportHandlerIPC( + nsISerialEventTarget* aCallbackThread) + : MediaTransportHandler(aCallbackThread) {} + +void MediaTransportHandlerIPC::Initialize() { + mInitPromise = net::SocketProcessBridgeChild::GetSocketProcessBridge()->Then( + mCallbackThread, __func__, + [this, self = RefPtr<MediaTransportHandlerIPC>(this)]( + const RefPtr<net::SocketProcessBridgeChild>& aBridge) { + ipc::PBackgroundChild* actor = + ipc::BackgroundChild::GetOrCreateSocketActorForCurrentThread(); + // An actor that can't send is possible if the socket process has + // crashed but hasn't been reconnected properly. See + // SocketProcessBridgeChild::ActorDestroy for more info. + if (!actor || !actor->CanSend()) { + NS_WARNING( + "MediaTransportHandlerIPC async init failed! Webrtc networking " + "will not work!"); + return InitPromise::CreateAndReject( + nsCString("GetOrCreateSocketActorForCurrentThread failed!"), + __func__); + } + MediaTransportChild* child = new MediaTransportChild(this); + // PBackgroungChild owns mChild! When it is done with it, + // mChild will let us know it it going away. + mChild = actor->SendPMediaTransportConstructor(child); + CSFLogDebug(LOGTAG, "%s Init done", __func__); + return InitPromise::CreateAndResolve(true, __func__); + }, + [=](const nsCString& aError) { + CSFLogError(LOGTAG, + "MediaTransportHandlerIPC async init failed! Webrtc " + "networking will not work! Error was %s", + aError.get()); + NS_WARNING( + "MediaTransportHandlerIPC async init failed! Webrtc networking " + "will not work!"); + return InitPromise::CreateAndReject(aError, __func__); + }); +} + +RefPtr<MediaTransportHandler::IceLogPromise> +MediaTransportHandlerIPC::GetIceLog(const nsCString& aPattern) { + return mInitPromise->Then( + mCallbackThread, __func__, + [=, self = RefPtr<MediaTransportHandlerIPC>(this)](bool /* dummy */) { + if (!mChild) { + return IceLogPromise::CreateAndReject(NS_ERROR_FAILURE, __func__); + } + // Compiler has trouble deducing the return type here for some reason, + // so we use a temp variable as a hint. + // SendGetIceLog _almost_ returns an IceLogPromise; the reject value + // differs (ipc::ResponseRejectReason vs nsresult) so we need to + // convert. + RefPtr<IceLogPromise> promise = mChild->SendGetIceLog(aPattern)->Then( + mCallbackThread, __func__, + [](WebrtcGlobalLog&& aLogLines) { + return IceLogPromise::CreateAndResolve(std::move(aLogLines), + __func__); + }, + [](ipc::ResponseRejectReason aReason) { + return IceLogPromise::CreateAndReject(NS_ERROR_FAILURE, __func__); + }); + return promise; + }, + [](const nsCString& aError) { + return IceLogPromise::CreateAndReject(NS_ERROR_FAILURE, __func__); + }); +} + +void MediaTransportHandlerIPC::ClearIceLog() { + mInitPromise->Then( + mCallbackThread, __func__, + [=, self = RefPtr<MediaTransportHandlerIPC>(this)](bool /*dummy*/) { + if (mChild) { + mChild->SendClearIceLog(); + } + }, + [](const nsCString& aError) {}); +} + +void MediaTransportHandlerIPC::EnterPrivateMode() { + mInitPromise->Then( + mCallbackThread, __func__, + [=, self = RefPtr<MediaTransportHandlerIPC>(this)](bool /*dummy*/) { + if (mChild) { + mChild->SendEnterPrivateMode(); + } + }, + [](const nsCString& aError) {}); +} + +void MediaTransportHandlerIPC::ExitPrivateMode() { + mInitPromise->Then( + mCallbackThread, __func__, + [=, self = RefPtr<MediaTransportHandlerIPC>(this)](bool /*dummy*/) { + if (mChild) { + mChild->SendExitPrivateMode(); + } + }, + [](const nsCString& aError) {}); +} + +void MediaTransportHandlerIPC::CreateIceCtx(const std::string& aName) { + CSFLogDebug(LOGTAG, "MediaTransportHandlerIPC::CreateIceCtx start"); + + mInitPromise->Then( + mCallbackThread, __func__, + [=, self = RefPtr<MediaTransportHandlerIPC>(this)](bool /*dummy*/) { + if (mChild) { + CSFLogDebug(LOGTAG, "%s starting", __func__); + if (NS_WARN_IF(!mChild->SendCreateIceCtx(aName))) { + CSFLogError(LOGTAG, "%s failed!", __func__); + } + } + }, + [](const nsCString& aError) {}); +} + +nsresult MediaTransportHandlerIPC::SetIceConfig( + const nsTArray<dom::RTCIceServer>& aIceServers, + dom::RTCIceTransportPolicy aIcePolicy) { + // Run some validation on this side of the IPC boundary so we can return + // errors synchronously. We don't actually use the results. It might make + // sense to move this check to PeerConnection and have this API take the + // converted form, but we would need to write IPC serialization code for + // the NrIce*Server types. + std::vector<NrIceStunServer> stunServers; + std::vector<NrIceTurnServer> turnServers; + nsresult rv = ConvertIceServers(aIceServers, &stunServers, &turnServers); + if (NS_FAILED(rv)) { + return rv; + } + + mInitPromise->Then( + mCallbackThread, __func__, + [=, iceServers = aIceServers.Clone(), + self = RefPtr<MediaTransportHandlerIPC>(this)](bool /*dummy*/) { + if (mChild) { + if (NS_WARN_IF(!mChild->SendSetIceConfig(std::move(iceServers), + aIcePolicy))) { + CSFLogError(LOGTAG, "%s failed!", __func__); + } + } + }, + [](const nsCString& aError) {}); + + return NS_OK; +} + +void MediaTransportHandlerIPC::Destroy() { + if (mChild) { + MediaTransportChild::Send__delete__(mChild); + mChild = nullptr; + } + delete this; +} + +// We will probably be able to move the proxy lookup stuff into +// this class once we move mtransport to its own process. +void MediaTransportHandlerIPC::SetProxyConfig( + NrSocketProxyConfig&& aProxyConfig) { + mInitPromise->Then( + mCallbackThread, __func__, + [aProxyConfig = std::move(aProxyConfig), this, + self = RefPtr<MediaTransportHandlerIPC>(this)](bool /*dummy*/) mutable { + if (mChild) { + mChild->SendSetProxyConfig(aProxyConfig.GetConfig()); + } + }, + [](const nsCString& aError) {}); +} + +void MediaTransportHandlerIPC::EnsureProvisionalTransport( + const std::string& aTransportId, const std::string& aLocalUfrag, + const std::string& aLocalPwd, int aComponentCount) { + mInitPromise->Then( + mCallbackThread, __func__, + [=, self = RefPtr<MediaTransportHandlerIPC>(this)](bool /*dummy*/) { + if (mChild) { + mChild->SendEnsureProvisionalTransport(aTransportId, aLocalUfrag, + aLocalPwd, aComponentCount); + } + }, + [](const nsCString& aError) {}); +} + +void MediaTransportHandlerIPC::SetTargetForDefaultLocalAddressLookup( + const std::string& aTargetIp, uint16_t aTargetPort) { + mInitPromise->Then( + mCallbackThread, __func__, + [=, self = RefPtr<MediaTransportHandlerIPC>(this)](bool /*dummy*/) { + if (mChild) { + mChild->SendSetTargetForDefaultLocalAddressLookup(aTargetIp, + aTargetPort); + } + }, + [](const nsCString& aError) {}); +} + +// We set default-route-only as late as possible because it depends on what +// capture permissions have been granted on the window, which could easily +// change between Init (ie; when the PC is created) and StartIceGathering +// (ie; when we set the local description). +void MediaTransportHandlerIPC::StartIceGathering( + bool aDefaultRouteOnly, bool aObfuscateHostAddresses, + // TODO(bug 1522205): It probably makes sense to look this up internally + const nsTArray<NrIceStunAddr>& aStunAddrs) { + mInitPromise->Then( + mCallbackThread, __func__, + [=, stunAddrs = aStunAddrs.Clone(), + self = RefPtr<MediaTransportHandlerIPC>(this)](bool /*dummy*/) { + if (mChild) { + mChild->SendStartIceGathering(aDefaultRouteOnly, + aObfuscateHostAddresses, stunAddrs); + } + }, + [](const nsCString& aError) {}); +} + +void MediaTransportHandlerIPC::ActivateTransport( + const std::string& aTransportId, const std::string& aLocalUfrag, + const std::string& aLocalPwd, size_t aComponentCount, + const std::string& aUfrag, const std::string& aPassword, + const nsTArray<uint8_t>& aKeyDer, const nsTArray<uint8_t>& aCertDer, + SSLKEAType aAuthType, bool aDtlsClient, const DtlsDigestList& aDigests, + bool aPrivacyRequested) { + mInitPromise->Then( + mCallbackThread, __func__, + [=, keyDer = aKeyDer.Clone(), certDer = aCertDer.Clone(), + self = RefPtr<MediaTransportHandlerIPC>(this)](bool /*dummy*/) { + if (mChild) { + mChild->SendActivateTransport(aTransportId, aLocalUfrag, aLocalPwd, + aComponentCount, aUfrag, aPassword, + keyDer, certDer, aAuthType, aDtlsClient, + aDigests, aPrivacyRequested); + } + }, + [](const nsCString& aError) {}); +} + +void MediaTransportHandlerIPC::RemoveTransportsExcept( + const std::set<std::string>& aTransportIds) { + std::vector<std::string> transportIds(aTransportIds.begin(), + aTransportIds.end()); + mInitPromise->Then( + mCallbackThread, __func__, + [=, self = RefPtr<MediaTransportHandlerIPC>(this)](bool /*dummy*/) { + if (mChild) { + mChild->SendRemoveTransportsExcept(transportIds); + } + }, + [](const nsCString& aError) {}); +} + +void MediaTransportHandlerIPC::StartIceChecks( + bool aIsControlling, const std::vector<std::string>& aIceOptions) { + mInitPromise->Then( + mCallbackThread, __func__, + [=, self = RefPtr<MediaTransportHandlerIPC>(this)](bool /*dummy*/) { + if (mChild) { + mChild->SendStartIceChecks(aIsControlling, aIceOptions); + } + }, + [](const nsCString& aError) {}); +} + +void MediaTransportHandlerIPC::SendPacket(const std::string& aTransportId, + MediaPacket&& aPacket) { + mInitPromise->Then( + mCallbackThread, __func__, + [this, self = RefPtr<MediaTransportHandlerIPC>(this), aTransportId, + aPacket = std::move(aPacket)](bool /*dummy*/) mutable { + if (mChild) { + mChild->SendSendPacket(aTransportId, aPacket); + } + }, + [](const nsCString& aError) {}); +} + +void MediaTransportHandlerIPC::AddIceCandidate( + const std::string& aTransportId, const std::string& aCandidate, + const std::string& aUfrag, const std::string& aObfuscatedAddress) { + mInitPromise->Then( + mCallbackThread, __func__, + [=, self = RefPtr<MediaTransportHandlerIPC>(this)](bool /*dummy*/) { + if (mChild) { + mChild->SendAddIceCandidate(aTransportId, aCandidate, aUfrag, + aObfuscatedAddress); + } + }, + [](const nsCString& aError) {}); +} + +void MediaTransportHandlerIPC::UpdateNetworkState(bool aOnline) { + mInitPromise->Then( + mCallbackThread, __func__, + [=, self = RefPtr<MediaTransportHandlerIPC>(this)](bool /*dummy*/) { + if (mChild) { + mChild->SendUpdateNetworkState(aOnline); + } + }, + [](const nsCString& aError) {}); +} + +RefPtr<dom::RTCStatsPromise> MediaTransportHandlerIPC::GetIceStats( + const std::string& aTransportId, DOMHighResTimeStamp aNow) { + using IPCPromise = dom::PMediaTransportChild::GetIceStatsPromise; + return mInitPromise + ->Then(mCallbackThread, __func__, + [aTransportId, aNow, this, self = RefPtr(this)]( + const InitPromise::ResolveOrRejectValue& aValue) { + if (aValue.IsReject()) { + return IPCPromise::CreateAndResolve( + MakeUnique<dom::RTCStatsCollection>(), + "MediaTransportHandlerIPC::GetIceStats_1"); + } + if (!mChild) { + return IPCPromise::CreateAndResolve( + MakeUnique<dom::RTCStatsCollection>(), + "MediaTransportHandlerIPC::GetIceStats_1"); + } + return mChild->SendGetIceStats(aTransportId, aNow); + }) + ->Then(mCallbackThread, __func__, + [](IPCPromise::ResolveOrRejectValue&& aValue) { + if (aValue.IsReject()) { + return dom::RTCStatsPromise::CreateAndResolve( + MakeUnique<dom::RTCStatsCollection>(), + "MediaTransportHandlerIPC::GetIceStats_2"); + } + return dom::RTCStatsPromise::CreateAndResolve( + std::move(aValue.ResolveValue()), + "MediaTransportHandlerIPC::GetIceStats_2"); + }); +} + +MediaTransportChild::MediaTransportChild(MediaTransportHandlerIPC* aUser) + : mUser(aUser) {} + +MediaTransportChild::~MediaTransportChild() { mUser->mChild = nullptr; } + +mozilla::ipc::IPCResult MediaTransportChild::RecvOnCandidate( + const string& transportId, const CandidateInfo& candidateInfo) { + mUser->OnCandidate(transportId, candidateInfo); + return ipc::IPCResult::Ok(); +} + +mozilla::ipc::IPCResult MediaTransportChild::RecvOnAlpnNegotiated( + const string& alpn) { + mUser->OnAlpnNegotiated(alpn); + return ipc::IPCResult::Ok(); +} + +mozilla::ipc::IPCResult MediaTransportChild::RecvOnGatheringStateChange( + const int& state) { + mUser->OnGatheringStateChange(static_cast<dom::RTCIceGatheringState>(state)); + return ipc::IPCResult::Ok(); +} + +mozilla::ipc::IPCResult MediaTransportChild::RecvOnConnectionStateChange( + const int& state) { + mUser->OnConnectionStateChange( + static_cast<dom::RTCIceConnectionState>(state)); + return ipc::IPCResult::Ok(); +} + +mozilla::ipc::IPCResult MediaTransportChild::RecvOnPacketReceived( + const string& transportId, const MediaPacket& packet) { + mUser->OnPacketReceived(transportId, packet); + return ipc::IPCResult::Ok(); +} + +mozilla::ipc::IPCResult MediaTransportChild::RecvOnEncryptedSending( + const string& transportId, const MediaPacket& packet) { + mUser->OnEncryptedSending(transportId, packet); + return ipc::IPCResult::Ok(); +} + +mozilla::ipc::IPCResult MediaTransportChild::RecvOnStateChange( + const string& transportId, const int& state) { + mUser->OnStateChange(transportId, static_cast<TransportLayer::State>(state)); + return ipc::IPCResult::Ok(); +} + +mozilla::ipc::IPCResult MediaTransportChild::RecvOnRtcpStateChange( + const string& transportId, const int& state) { + mUser->OnRtcpStateChange(transportId, + static_cast<TransportLayer::State>(state)); + return ipc::IPCResult::Ok(); +} + +} // namespace mozilla diff --git a/dom/media/webrtc/jsapi/MediaTransportHandlerIPC.h b/dom/media/webrtc/jsapi/MediaTransportHandlerIPC.h new file mode 100644 index 0000000000..6b285dee2a --- /dev/null +++ b/dom/media/webrtc/jsapi/MediaTransportHandlerIPC.h @@ -0,0 +1,96 @@ +/* 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/. */ + +#ifndef _MTRANSPORTHANDLER_IPC_H__ +#define _MTRANSPORTHANDLER_IPC_H__ + +#include "jsapi/MediaTransportHandler.h" +#include "mozilla/dom/PMediaTransportChild.h" + +namespace mozilla { + +class MediaTransportChild; + +// Implementation of MediaTransportHandler that uses IPC (PMediaTransport) to +// talk to mtransport on another process. +class MediaTransportHandlerIPC final : public MediaTransportHandler { + public: + explicit MediaTransportHandlerIPC(nsISerialEventTarget* aCallbackThread); + void Initialize() override; + RefPtr<IceLogPromise> GetIceLog(const nsCString& aPattern) override; + void ClearIceLog() override; + void EnterPrivateMode() override; + void ExitPrivateMode() override; + + void CreateIceCtx(const std::string& aName) override; + + nsresult SetIceConfig(const nsTArray<dom::RTCIceServer>& aIceServers, + dom::RTCIceTransportPolicy aIcePolicy) override; + + // We will probably be able to move the proxy lookup stuff into + // this class once we move mtransport to its own process. + void SetProxyConfig(NrSocketProxyConfig&& aProxyConfig) override; + + void EnsureProvisionalTransport(const std::string& aTransportId, + const std::string& aLocalUfrag, + const std::string& aLocalPwd, + int aComponentCount) override; + + void SetTargetForDefaultLocalAddressLookup(const std::string& aTargetIp, + uint16_t aTargetPort) override; + + // We set default-route-only as late as possible because it depends on what + // capture permissions have been granted on the window, which could easily + // change between Init (ie; when the PC is created) and StartIceGathering + // (ie; when we set the local description). + void StartIceGathering(bool aDefaultRouteOnly, bool aObfuscateHostAddresses, + // TODO: It probably makes sense to look + // this up internally + const nsTArray<NrIceStunAddr>& aStunAddrs) override; + + void ActivateTransport( + const std::string& aTransportId, const std::string& aLocalUfrag, + const std::string& aLocalPwd, size_t aComponentCount, + const std::string& aUfrag, const std::string& aPassword, + const nsTArray<uint8_t>& aKeyDer, const nsTArray<uint8_t>& aCertDer, + SSLKEAType aAuthType, bool aDtlsClient, const DtlsDigestList& aDigests, + bool aPrivacyRequested) override; + + void RemoveTransportsExcept( + const std::set<std::string>& aTransportIds) override; + + void StartIceChecks(bool aIsControlling, + const std::vector<std::string>& aIceOptions) override; + + void SendPacket(const std::string& aTransportId, + MediaPacket&& aPacket) override; + + void AddIceCandidate(const std::string& aTransportId, + const std::string& aCandidate, const std::string& aUfrag, + const std::string& aObfuscatedAddress) override; + + void UpdateNetworkState(bool aOnline) override; + + RefPtr<dom::RTCStatsPromise> GetIceStats(const std::string& aTransportId, + DOMHighResTimeStamp aNow) override; + + private: + friend class MediaTransportChild; + void Destroy() override; + + // We do not own this; it will tell us when it is going away. + dom::PMediaTransportChild* mChild = nullptr; + + // |mChild| can only be initted asynchronously, |mInitPromise| resolves + // when that happens. The |Then| calls make it convenient to dispatch API + // calls to main, which is a bonus. + // Init promise is not exclusive; this lets us call |Then| on it for every + // API call we get, instead of creating another promise each time. + typedef MozPromise<bool, nsCString, false> InitPromise; + RefPtr<InitPromise> mInitPromise; +}; + +} // namespace mozilla + +#endif //_MTRANSPORTHANDLER_IPC_H__ diff --git a/dom/media/webrtc/jsapi/MediaTransportParent.cpp b/dom/media/webrtc/jsapi/MediaTransportParent.cpp new file mode 100644 index 0000000000..d0f90df8c5 --- /dev/null +++ b/dom/media/webrtc/jsapi/MediaTransportParent.cpp @@ -0,0 +1,240 @@ +/* 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 "mozilla/dom/MediaTransportParent.h" +#include "jsapi/MediaTransportHandler.h" + +#include "transport/sigslot.h" +#include "common/browser_logging/CSFLog.h" + +namespace mozilla { + +// Deals with the MediaTransportHandler interface, so MediaTransportParent +// doesn't have to.. +class MediaTransportParent::Impl : public sigslot::has_slots<> { + public: + explicit Impl(MediaTransportParent* aParent) + : mHandler(MediaTransportHandler::Create(GetCurrentSerialEventTarget())), + mParent(aParent) { + mHandler->SignalCandidate.connect(this, + &MediaTransportParent::Impl::OnCandidate); + mHandler->SignalAlpnNegotiated.connect( + this, &MediaTransportParent::Impl::OnAlpnNegotiated); + mHandler->SignalGatheringStateChange.connect( + this, &MediaTransportParent::Impl::OnGatheringStateChange); + mHandler->SignalConnectionStateChange.connect( + this, &MediaTransportParent::Impl::OnConnectionStateChange); + mHandler->SignalPacketReceived.connect( + this, &MediaTransportParent::Impl::OnPacketReceived); + mHandler->SignalEncryptedSending.connect( + this, &MediaTransportParent::Impl::OnEncryptedSending); + mHandler->SignalStateChange.connect( + this, &MediaTransportParent::Impl::OnStateChange); + mHandler->SignalRtcpStateChange.connect( + this, &MediaTransportParent::Impl::OnRtcpStateChange); + } + + virtual ~Impl() { + disconnect_all(); + mHandler = nullptr; + } + + void OnCandidate(const std::string& aTransportId, + const CandidateInfo& aCandidateInfo) { + NS_ENSURE_TRUE_VOID(mParent->SendOnCandidate(aTransportId, aCandidateInfo)); + } + + void OnAlpnNegotiated(const std::string& aAlpn, bool aPrivacyRequested) { + NS_ENSURE_TRUE_VOID(mParent->SendOnAlpnNegotiated(aAlpn)); + } + + void OnGatheringStateChange(dom::RTCIceGatheringState aState) { + NS_ENSURE_TRUE_VOID( + mParent->SendOnGatheringStateChange(static_cast<int>(aState))); + } + + void OnConnectionStateChange(dom::RTCIceConnectionState aState) { + NS_ENSURE_TRUE_VOID( + mParent->SendOnConnectionStateChange(static_cast<int>(aState))); + } + + void OnPacketReceived(const std::string& aTransportId, + const MediaPacket& aPacket) { + NS_ENSURE_TRUE_VOID(mParent->SendOnPacketReceived(aTransportId, aPacket)); + } + + void OnEncryptedSending(const std::string& aTransportId, + const MediaPacket& aPacket) { + NS_ENSURE_TRUE_VOID(mParent->SendOnEncryptedSending(aTransportId, aPacket)); + } + + void OnStateChange(const std::string& aTransportId, + TransportLayer::State aState) { + NS_ENSURE_TRUE_VOID(mParent->SendOnStateChange(aTransportId, aState)); + } + + void OnRtcpStateChange(const std::string& aTransportId, + TransportLayer::State aState) { + NS_ENSURE_TRUE_VOID(mParent->SendOnRtcpStateChange(aTransportId, aState)); + } + + RefPtr<MediaTransportHandler> mHandler; + + private: + MediaTransportParent* mParent; +}; + +MediaTransportParent::MediaTransportParent() : mImpl(new Impl(this)) {} + +MediaTransportParent::~MediaTransportParent() {} + +mozilla::ipc::IPCResult MediaTransportParent::RecvGetIceLog( + const nsCString& pattern, GetIceLogResolver&& aResolve) { + mImpl->mHandler->GetIceLog(pattern)->Then( + GetCurrentSerialEventTarget(), __func__, + // IPDL doesn't give us a reject function, so we cannot reject async, so + // we are forced to resolve with an empty result. Laaaaaaame. + [aResolve = std::move(aResolve)]( + MediaTransportHandler::IceLogPromise::ResolveOrRejectValue&& + aResult) mutable { + WebrtcGlobalLog logLines; + if (aResult.IsResolve()) { + logLines = std::move(aResult.ResolveValue()); + } + aResolve(logLines); + }); + + return ipc::IPCResult::Ok(); +} + +mozilla::ipc::IPCResult MediaTransportParent::RecvClearIceLog() { + mImpl->mHandler->ClearIceLog(); + return ipc::IPCResult::Ok(); +} + +mozilla::ipc::IPCResult MediaTransportParent::RecvEnterPrivateMode() { + mImpl->mHandler->EnterPrivateMode(); + return ipc::IPCResult::Ok(); +} + +mozilla::ipc::IPCResult MediaTransportParent::RecvExitPrivateMode() { + mImpl->mHandler->ExitPrivateMode(); + return ipc::IPCResult::Ok(); +} + +mozilla::ipc::IPCResult MediaTransportParent::RecvCreateIceCtx( + const string& name) { + mImpl->mHandler->CreateIceCtx(name); + return ipc::IPCResult::Ok(); +} + +mozilla::ipc::IPCResult MediaTransportParent::RecvSetIceConfig( + nsTArray<RTCIceServer>&& iceServers, + const RTCIceTransportPolicy& icePolicy) { + nsresult rv = mImpl->mHandler->SetIceConfig(iceServers, icePolicy); + if (NS_FAILED(rv)) { + return ipc::IPCResult::Fail(WrapNotNull(this), __func__, + "MediaTransportHandler::SetIceConfig failed"); + } + return ipc::IPCResult::Ok(); +} + +mozilla::ipc::IPCResult MediaTransportParent::RecvSetProxyConfig( + const net::WebrtcProxyConfig& aProxyConfig) { + mImpl->mHandler->SetProxyConfig(NrSocketProxyConfig(aProxyConfig)); + return ipc::IPCResult::Ok(); +} + +mozilla::ipc::IPCResult MediaTransportParent::RecvEnsureProvisionalTransport( + const string& transportId, const string& localUfrag, const string& localPwd, + const int& componentCount) { + mImpl->mHandler->EnsureProvisionalTransport(transportId, localUfrag, localPwd, + componentCount); + return ipc::IPCResult::Ok(); +} + +mozilla::ipc::IPCResult +MediaTransportParent::RecvSetTargetForDefaultLocalAddressLookup( + const std::string& targetIp, uint16_t targetPort) { + mImpl->mHandler->SetTargetForDefaultLocalAddressLookup(targetIp, targetPort); + return ipc::IPCResult::Ok(); +} + +mozilla::ipc::IPCResult MediaTransportParent::RecvStartIceGathering( + const bool& defaultRouteOnly, const bool& obfuscateHostAddresses, + const net::NrIceStunAddrArray& stunAddrs) { + mImpl->mHandler->StartIceGathering(defaultRouteOnly, obfuscateHostAddresses, + stunAddrs); + return ipc::IPCResult::Ok(); +} + +mozilla::ipc::IPCResult MediaTransportParent::RecvActivateTransport( + const string& transportId, const string& localUfrag, const string& localPwd, + const int& componentCount, const string& remoteUfrag, + const string& remotePwd, nsTArray<uint8_t>&& keyDer, + nsTArray<uint8_t>&& certDer, const int& authType, const bool& dtlsClient, + const DtlsDigestList& digests, const bool& privacyRequested) { + mImpl->mHandler->ActivateTransport( + transportId, localUfrag, localPwd, componentCount, remoteUfrag, remotePwd, + keyDer, certDer, static_cast<SSLKEAType>(authType), dtlsClient, digests, + privacyRequested); + return ipc::IPCResult::Ok(); +} + +mozilla::ipc::IPCResult MediaTransportParent::RecvRemoveTransportsExcept( + const StringVector& transportIds) { + std::set<std::string> ids(transportIds.begin(), transportIds.end()); + mImpl->mHandler->RemoveTransportsExcept(ids); + return ipc::IPCResult::Ok(); +} + +mozilla::ipc::IPCResult MediaTransportParent::RecvStartIceChecks( + const bool& isControlling, const StringVector& iceOptions) { + mImpl->mHandler->StartIceChecks(isControlling, iceOptions); + return ipc::IPCResult::Ok(); +} + +mozilla::ipc::IPCResult MediaTransportParent::RecvSendPacket( + const string& transportId, MediaPacket&& packet) { + mImpl->mHandler->SendPacket(transportId, std::move(packet)); + return ipc::IPCResult::Ok(); +} + +mozilla::ipc::IPCResult MediaTransportParent::RecvAddIceCandidate( + const string& transportId, const string& candidate, const string& ufrag, + const string& obfuscatedAddr) { + mImpl->mHandler->AddIceCandidate(transportId, candidate, ufrag, + obfuscatedAddr); + return ipc::IPCResult::Ok(); +} + +mozilla::ipc::IPCResult MediaTransportParent::RecvUpdateNetworkState( + const bool& online) { + mImpl->mHandler->UpdateNetworkState(online); + return ipc::IPCResult::Ok(); +} + +mozilla::ipc::IPCResult MediaTransportParent::RecvGetIceStats( + const string& transportId, const double& now, + GetIceStatsResolver&& aResolve) { + mImpl->mHandler->GetIceStats(transportId, now) + ->Then( + GetCurrentSerialEventTarget(), __func__, + // IPDL doesn't give us a reject function, so we cannot reject async, + // so we are forced to resolve with an unmodified result. Laaaaaaame. + [aResolve = std::move(aResolve)]( + dom::RTCStatsPromise::ResolveOrRejectValue&& aResult) { + if (aResult.IsResolve()) { + aResolve(aResult.ResolveValue()); + } else { + aResolve(MakeUnique<dom::RTCStatsCollection>()); + } + }); + + return ipc::IPCResult::Ok(); +} + +void MediaTransportParent::ActorDestroy(ActorDestroyReason aWhy) {} + +} // namespace mozilla diff --git a/dom/media/webrtc/jsapi/PacketDumper.cpp b/dom/media/webrtc/jsapi/PacketDumper.cpp new file mode 100644 index 0000000000..2b62e0806e --- /dev/null +++ b/dom/media/webrtc/jsapi/PacketDumper.cpp @@ -0,0 +1,124 @@ +/* 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 "jsapi/PacketDumper.h" +#include "jsapi/PeerConnectionImpl.h" +#include "mozilla/media/MediaUtils.h" // NewRunnableFrom +#include "nsThreadUtils.h" // NS_DispatchToMainThread + +namespace mozilla { + +/* static */ +RefPtr<PacketDumper> PacketDumper::GetPacketDumper( + const std::string& aPcHandle) { + MOZ_ASSERT(NS_IsMainThread()); + PeerConnectionWrapper pcw(aPcHandle); + if (pcw.impl()) { + return pcw.impl()->GetPacketDumper(); + } + + return new PacketDumper(""); +} + +PacketDumper::PacketDumper(const std::string& aPcHandle) + : mPcHandle(aPcHandle), + mPacketDumpEnabled(false), + mPacketDumpFlagsMutex("Packet dump flags mutex") {} + +void PacketDumper::Dump(size_t aLevel, dom::mozPacketDumpType aType, + bool aSending, const void* aData, size_t aSize) { + // Optimization; avoids making a copy of the buffer, but we need to lock a + // mutex and check the flags. Could be optimized further, if we really want to + if (!ShouldDumpPacket(aLevel, aType, aSending)) { + return; + } + + UniquePtr<uint8_t[]> ownedPacket = MakeUnique<uint8_t[]>(aSize); + memcpy(ownedPacket.get(), aData, aSize); + + RefPtr<Runnable> dumpRunnable = media::NewRunnableFrom(std::bind( + [this, self = RefPtr<PacketDumper>(this), aLevel, aType, aSending, + aSize](UniquePtr<uint8_t[]>& aPacket) -> nsresult { + // Check again; packet dump might have been disabled since the dispatch + if (ShouldDumpPacket(aLevel, aType, aSending)) { + PeerConnectionWrapper pcw(mPcHandle); + RefPtr<PeerConnectionImpl> pc = pcw.impl(); + if (pc) { + pc->DumpPacket_m(aLevel, aType, aSending, aPacket, aSize); + } + } + return NS_OK; + }, + std::move(ownedPacket))); + + NS_DispatchToMainThread(dumpRunnable); +} + +nsresult PacketDumper::EnablePacketDump(unsigned long aLevel, + dom::mozPacketDumpType aType, + bool aSending) { + mPacketDumpEnabled = true; + std::vector<unsigned>* packetDumpFlags; + if (aSending) { + packetDumpFlags = &mSendPacketDumpFlags; + } else { + packetDumpFlags = &mRecvPacketDumpFlags; + } + + unsigned flag = 1 << (unsigned)aType; + + MutexAutoLock lock(mPacketDumpFlagsMutex); + if (aLevel >= packetDumpFlags->size()) { + packetDumpFlags->resize(aLevel + 1); + } + + (*packetDumpFlags)[aLevel] |= flag; + return NS_OK; +} + +nsresult PacketDumper::DisablePacketDump(unsigned long aLevel, + dom::mozPacketDumpType aType, + bool aSending) { + std::vector<unsigned>* packetDumpFlags; + if (aSending) { + packetDumpFlags = &mSendPacketDumpFlags; + } else { + packetDumpFlags = &mRecvPacketDumpFlags; + } + + unsigned flag = 1 << (unsigned)aType; + + MutexAutoLock lock(mPacketDumpFlagsMutex); + if (aLevel < packetDumpFlags->size()) { + (*packetDumpFlags)[aLevel] &= ~flag; + } + + return NS_OK; +} + +bool PacketDumper::ShouldDumpPacket(size_t aLevel, dom::mozPacketDumpType aType, + bool aSending) const { + if (!mPacketDumpEnabled) { + return false; + } + + MutexAutoLock lock(mPacketDumpFlagsMutex); + + const std::vector<unsigned>* packetDumpFlags; + + if (aSending) { + packetDumpFlags = &mSendPacketDumpFlags; + } else { + packetDumpFlags = &mRecvPacketDumpFlags; + } + + if (aLevel < packetDumpFlags->size()) { + unsigned flag = 1 << (unsigned)aType; + return flag & packetDumpFlags->at(aLevel); + } + + return false; +} + +} // namespace mozilla diff --git a/dom/media/webrtc/jsapi/PacketDumper.h b/dom/media/webrtc/jsapi/PacketDumper.h new file mode 100644 index 0000000000..e998b3871f --- /dev/null +++ b/dom/media/webrtc/jsapi/PacketDumper.h @@ -0,0 +1,52 @@ +/* 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/. */ + +#ifndef _PACKET_DUMPER_H_ +#define _PACKET_DUMPER_H_ + +#include "nsISupportsImpl.h" +#include "mozilla/RefPtr.h" +#include "mozilla/dom/RTCPeerConnectionBinding.h" + +#include <vector> + +namespace mozilla { +class PeerConnectionImpl; + +class PacketDumper { + public: + static RefPtr<PacketDumper> GetPacketDumper(const std::string& aPcHandle); + + NS_INLINE_DECL_THREADSAFE_REFCOUNTING(PacketDumper) + + PacketDumper(const PacketDumper&) = delete; + PacketDumper& operator=(const PacketDumper&) = delete; + + void Dump(size_t aLevel, dom::mozPacketDumpType aType, bool aSending, + const void* aData, size_t aSize); + + nsresult EnablePacketDump(unsigned long aLevel, dom::mozPacketDumpType aType, + bool aSending); + + nsresult DisablePacketDump(unsigned long aLevel, dom::mozPacketDumpType aType, + bool aSending); + + private: + friend class PeerConnectionImpl; + explicit PacketDumper(const std::string& aPcHandle); + ~PacketDumper() = default; + bool ShouldDumpPacket(size_t aLevel, dom::mozPacketDumpType aType, + bool aSending) const; + + // This class is not cycle-collected, so it cannot hold onto a strong ref + const std::string mPcHandle; + std::vector<unsigned> mSendPacketDumpFlags; + std::vector<unsigned> mRecvPacketDumpFlags; + Atomic<bool> mPacketDumpEnabled; + mutable Mutex mPacketDumpFlagsMutex; +}; + +} // namespace mozilla + +#endif // _PACKET_DUMPER_H_ diff --git a/dom/media/webrtc/jsapi/PeerConnectionCtx.cpp b/dom/media/webrtc/jsapi/PeerConnectionCtx.cpp new file mode 100644 index 0000000000..9a8f27fb59 --- /dev/null +++ b/dom/media/webrtc/jsapi/PeerConnectionCtx.cpp @@ -0,0 +1,650 @@ +/* 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 "PeerConnectionCtx.h" + +#include "WebrtcGlobalStatsHistory.h" +#include "api/audio/audio_mixer.h" +#include "api/audio_codecs/builtin_audio_decoder_factory.h" +#include "modules/rtp_rtcp/source/rtp_header_extensions.h" +#include "call/audio_state.h" +#include "common/browser_logging/CSFLog.h" +#include "common/browser_logging/WebRtcLog.h" +#include "gmp-video-decode.h" // GMP_API_VIDEO_DECODER +#include "gmp-video-encode.h" // GMP_API_VIDEO_ENCODER +#include "libwebrtcglue/CallWorkerThread.h" +#include "modules/audio_device/include/fake_audio_device.h" +#include "modules/audio_processing/include/audio_processing.h" +#include "modules/audio_processing/include/aec_dump.h" +#include "mozilla/UniquePtr.h" +#include "mozilla/dom/RTCPeerConnectionBinding.h" +#include "mozilla/Preferences.h" +#include "mozilla/Services.h" +#include "mozilla/StaticPtr.h" +#include "mozilla/Telemetry.h" +#include "mozilla/Types.h" +#include "mozilla/dom/RTCStatsReportBinding.h" +#include "nsCRTGlue.h" +#include "nsIIOService.h" +#include "nsIObserver.h" +#include "nsIObserverService.h" +#include "nsNetCID.h" // NS_SOCKETTRANSPORTSERVICE_CONTRACTID +#include "nsServiceManagerUtils.h" // do_GetService +#include "PeerConnectionImpl.h" +#include "prcvar.h" +#include "transport/runnable_utils.h" +#include "WebrtcGlobalChild.h" +#include "WebrtcGlobalInformation.h" + +static const char* pccLogTag = "PeerConnectionCtx"; +#ifdef LOGTAG +# undef LOGTAG +#endif +#define LOGTAG pccLogTag + +using namespace webrtc; + +namespace { +class DummyAudioMixer : public AudioMixer { + public: + bool AddSource(Source*) override { return true; } + void RemoveSource(Source*) override {} + void Mix(size_t, AudioFrame*) override { MOZ_CRASH("Unexpected call"); } +}; + +class DummyAudioProcessing : public AudioProcessing { + public: + int Initialize() override { + MOZ_CRASH("Unexpected call"); + return kNoError; + } + int Initialize(const ProcessingConfig&) override { return Initialize(); } + void ApplyConfig(const Config&) override { MOZ_CRASH("Unexpected call"); } + int proc_sample_rate_hz() const override { + MOZ_CRASH("Unexpected call"); + return 0; + } + int proc_split_sample_rate_hz() const override { + MOZ_CRASH("Unexpected call"); + return 0; + } + size_t num_input_channels() const override { + MOZ_CRASH("Unexpected call"); + return 0; + } + size_t num_proc_channels() const override { + MOZ_CRASH("Unexpected call"); + return 0; + } + size_t num_output_channels() const override { + MOZ_CRASH("Unexpected call"); + return 0; + } + size_t num_reverse_channels() const override { + MOZ_CRASH("Unexpected call"); + return 0; + } + void set_output_will_be_muted(bool) override { MOZ_CRASH("Unexpected call"); } + void SetRuntimeSetting(RuntimeSetting) override { + MOZ_CRASH("Unexpected call"); + } + bool PostRuntimeSetting(RuntimeSetting setting) override { return false; } + int ProcessStream(const int16_t* const, const StreamConfig&, + const StreamConfig&, int16_t* const) override { + MOZ_CRASH("Unexpected call"); + return kNoError; + } + int ProcessStream(const float* const*, const StreamConfig&, + const StreamConfig&, float* const*) override { + MOZ_CRASH("Unexpected call"); + return kNoError; + } + int ProcessReverseStream(const int16_t* const, const StreamConfig&, + const StreamConfig&, int16_t* const) override { + MOZ_CRASH("Unexpected call"); + return kNoError; + } + int ProcessReverseStream(const float* const*, const StreamConfig&, + const StreamConfig&, float* const*) override { + MOZ_CRASH("Unexpected call"); + return kNoError; + } + int AnalyzeReverseStream(const float* const*, const StreamConfig&) override { + MOZ_CRASH("Unexpected call"); + return kNoError; + } + bool GetLinearAecOutput( + rtc::ArrayView<std::array<float, 160>>) const override { + MOZ_CRASH("Unexpected call"); + return false; + } + void set_stream_analog_level(int) override { MOZ_CRASH("Unexpected call"); } + int recommended_stream_analog_level() const override { + MOZ_CRASH("Unexpected call"); + return -1; + } + int set_stream_delay_ms(int) override { + MOZ_CRASH("Unexpected call"); + return kNoError; + } + int stream_delay_ms() const override { + MOZ_CRASH("Unexpected call"); + return 0; + } + void set_stream_key_pressed(bool) override { MOZ_CRASH("Unexpected call"); } + bool CreateAndAttachAecDump(absl::string_view, int64_t, + rtc::TaskQueue*) override { + MOZ_CRASH("Unexpected call"); + return false; + } + bool CreateAndAttachAecDump(FILE*, int64_t, rtc::TaskQueue*) override { + MOZ_CRASH("Unexpected call"); + return false; + } + void AttachAecDump(std::unique_ptr<AecDump>) override { + MOZ_CRASH("Unexpected call"); + } + void DetachAecDump() override { MOZ_CRASH("Unexpected call"); } + AudioProcessingStats GetStatistics() override { + return AudioProcessingStats(); + } + AudioProcessingStats GetStatistics(bool) override { return GetStatistics(); } + AudioProcessing::Config GetConfig() const override { + MOZ_CRASH("Unexpected call"); + return Config(); + } +}; +} // namespace + +namespace mozilla { + +using namespace dom; + +SharedWebrtcState::SharedWebrtcState( + RefPtr<AbstractThread> aCallWorkerThread, + webrtc::AudioState::Config&& aAudioStateConfig, + RefPtr<webrtc::AudioDecoderFactory> aAudioDecoderFactory, + UniquePtr<webrtc::WebRtcKeyValueConfig> aTrials) + : mCallWorkerThread(std::move(aCallWorkerThread)), + mAudioStateConfig(std::move(aAudioStateConfig)), + mAudioDecoderFactory(std::move(aAudioDecoderFactory)), + mTrials(std::move(aTrials)) {} + +SharedWebrtcState::~SharedWebrtcState() = default; + +class PeerConnectionCtxObserver : public nsIObserver { + public: + NS_DECL_ISUPPORTS + + PeerConnectionCtxObserver() {} + + void Init() { + nsCOMPtr<nsIObserverService> observerService = + services::GetObserverService(); + if (!observerService) return; + + nsresult rv = NS_OK; + + rv = observerService->AddObserver(this, NS_XPCOM_WILL_SHUTDOWN_OBSERVER_ID, + false); + MOZ_ALWAYS_SUCCEEDS(rv); + rv = observerService->AddObserver(this, NS_IOSERVICE_OFFLINE_STATUS_TOPIC, + false); + MOZ_ALWAYS_SUCCEEDS(rv); + (void)rv; + } + + NS_IMETHOD Observe(nsISupports* aSubject, const char* aTopic, + const char16_t* aData) override { + if (strcmp(aTopic, NS_XPCOM_WILL_SHUTDOWN_OBSERVER_ID) == 0) { + CSFLogDebug(LOGTAG, "Shutting down PeerConnectionCtx"); + PeerConnectionCtx::Destroy(); + + nsCOMPtr<nsIObserverService> observerService = + services::GetObserverService(); + if (!observerService) return NS_ERROR_FAILURE; + + nsresult rv = observerService->RemoveObserver( + this, NS_IOSERVICE_OFFLINE_STATUS_TOPIC); + MOZ_ALWAYS_SUCCEEDS(rv); + rv = observerService->RemoveObserver(this, + NS_XPCOM_WILL_SHUTDOWN_OBSERVER_ID); + MOZ_ALWAYS_SUCCEEDS(rv); + + // Make sure we're not deleted while still inside ::Observe() + RefPtr<PeerConnectionCtxObserver> kungFuDeathGrip(this); + PeerConnectionCtx::gPeerConnectionCtxObserver = nullptr; + } + if (strcmp(aTopic, NS_IOSERVICE_OFFLINE_STATUS_TOPIC) == 0) { + if (NS_strcmp(aData, u"" NS_IOSERVICE_OFFLINE) == 0) { + CSFLogDebug(LOGTAG, "Updating network state to offline"); + PeerConnectionCtx::UpdateNetworkState(false); + } else if (NS_strcmp(aData, u"" NS_IOSERVICE_ONLINE) == 0) { + CSFLogDebug(LOGTAG, "Updating network state to online"); + PeerConnectionCtx::UpdateNetworkState(true); + } else { + CSFLogDebug(LOGTAG, "Received unsupported network state event"); + MOZ_CRASH(); + } + } + return NS_OK; + } + + private: + virtual ~PeerConnectionCtxObserver() { + nsCOMPtr<nsIObserverService> observerService = + services::GetObserverService(); + if (observerService) { + observerService->RemoveObserver(this, NS_IOSERVICE_OFFLINE_STATUS_TOPIC); + observerService->RemoveObserver(this, NS_XPCOM_WILL_SHUTDOWN_OBSERVER_ID); + } + } +}; + +NS_IMPL_ISUPPORTS(PeerConnectionCtxObserver, nsIObserver); + +PeerConnectionCtx* PeerConnectionCtx::gInstance; +StaticRefPtr<PeerConnectionCtxObserver> + PeerConnectionCtx::gPeerConnectionCtxObserver; + +nsresult PeerConnectionCtx::InitializeGlobal() { + MOZ_ASSERT(NS_IsMainThread()); + + nsresult res; + + if (!gInstance) { + CSFLogDebug(LOGTAG, "Creating PeerConnectionCtx"); + PeerConnectionCtx* ctx = new PeerConnectionCtx(); + + res = ctx->Initialize(); + PR_ASSERT(NS_SUCCEEDED(res)); + if (!NS_SUCCEEDED(res)) return res; + + gInstance = ctx; + + if (!PeerConnectionCtx::gPeerConnectionCtxObserver) { + PeerConnectionCtx::gPeerConnectionCtxObserver = + new PeerConnectionCtxObserver(); + PeerConnectionCtx::gPeerConnectionCtxObserver->Init(); + } + } + + EnableWebRtcLog(); + return NS_OK; +} + +PeerConnectionCtx* PeerConnectionCtx::GetInstance() { + MOZ_ASSERT(gInstance); + return gInstance; +} + +bool PeerConnectionCtx::isActive() { return gInstance; } + +void PeerConnectionCtx::Destroy() { + CSFLogDebug(LOGTAG, "%s", __FUNCTION__); + + if (gInstance) { + // Null out gInstance first, so PeerConnectionImpl doesn't try to use it + // in Cleanup. + auto* instance = gInstance; + gInstance = nullptr; + instance->Cleanup(); + delete instance; + } + + StopWebRtcLog(); +} + +template <typename T> +static void RecordCommonRtpTelemetry(const T& list, const T& lastList, + const bool isRemote) { + using namespace Telemetry; + for (const auto& s : list) { + const bool isAudio = s.mKind.Find(u"audio") != -1; + if (s.mPacketsLost.WasPassed() && s.mPacketsReceived.WasPassed()) { + if (const uint64_t total = + s.mPacketsLost.Value() + s.mPacketsReceived.Value()) { + HistogramID id = + isRemote ? (isAudio ? WEBRTC_AUDIO_QUALITY_OUTBOUND_PACKETLOSS_RATE + : WEBRTC_VIDEO_QUALITY_OUTBOUND_PACKETLOSS_RATE) + : (isAudio ? WEBRTC_AUDIO_QUALITY_INBOUND_PACKETLOSS_RATE + : WEBRTC_VIDEO_QUALITY_INBOUND_PACKETLOSS_RATE); + Accumulate(id, (s.mPacketsLost.Value() * 1000) / total); + } + } + if (s.mJitter.WasPassed()) { + HistogramID id = isRemote + ? (isAudio ? WEBRTC_AUDIO_QUALITY_OUTBOUND_JITTER + : WEBRTC_VIDEO_QUALITY_OUTBOUND_JITTER) + : (isAudio ? WEBRTC_AUDIO_QUALITY_INBOUND_JITTER + : WEBRTC_VIDEO_QUALITY_INBOUND_JITTER); + Accumulate(id, s.mJitter.Value() * 1000); + } + } +} + +// Telemetry reporting every second after start of first call. +// The threading model around the media pipelines is weird: +// - The pipelines are containers, +// - containers that are only safe on main thread, with members only safe on +// STS, +// - hence the there and back again approach. + +void PeerConnectionCtx::DeliverStats( + UniquePtr<dom::RTCStatsReportInternal>&& aReport) { + using namespace Telemetry; + + // First, get reports from a second ago, if any, for calculations below + UniquePtr<dom::RTCStatsReportInternal> lastReport; + { + auto i = mLastReports.find(aReport->mPcid); + if (i != mLastReports.end()) { + lastReport = std::move(i->second); + } else { + lastReport = MakeUnique<dom::RTCStatsReportInternal>(); + } + } + // Record Telemetery + RecordCommonRtpTelemetry(aReport->mInboundRtpStreamStats, + lastReport->mInboundRtpStreamStats, false); + // Record bandwidth telemetry + for (const auto& s : aReport->mInboundRtpStreamStats) { + if (s.mBytesReceived.WasPassed()) { + const bool isAudio = s.mKind.Find(u"audio") != -1; + for (const auto& lastS : lastReport->mInboundRtpStreamStats) { + if (lastS.mId == s.mId) { + int32_t deltaMs = s.mTimestamp.Value() - lastS.mTimestamp.Value(); + // In theory we're called every second, so delta *should* be in that + // range. Small deltas could cause errors due to division + if (deltaMs < 500 || deltaMs > 60000 || + !lastS.mBytesReceived.WasPassed()) { + break; + } + HistogramID id = isAudio + ? WEBRTC_AUDIO_QUALITY_INBOUND_BANDWIDTH_KBITS + : WEBRTC_VIDEO_QUALITY_INBOUND_BANDWIDTH_KBITS; + // We could accumulate values until enough time has passed + // and then Accumulate() but this isn't that important + Accumulate( + id, + ((s.mBytesReceived.Value() - lastS.mBytesReceived.Value()) * 8) / + deltaMs); + break; + } + } + } + } + RecordCommonRtpTelemetry(aReport->mRemoteInboundRtpStreamStats, + lastReport->mRemoteInboundRtpStreamStats, true); + for (const auto& s : aReport->mRemoteInboundRtpStreamStats) { + if (s.mRoundTripTime.WasPassed()) { + const bool isAudio = s.mKind.Find(u"audio") != -1; + HistogramID id = isAudio ? WEBRTC_AUDIO_QUALITY_OUTBOUND_RTT + : WEBRTC_VIDEO_QUALITY_OUTBOUND_RTT; + Accumulate(id, s.mRoundTripTime.Value() * 1000); + } + } + + mLastReports[aReport->mPcid] = std::move(aReport); +} + +void PeerConnectionCtx::EverySecondTelemetryCallback_m(nsITimer* timer, + void* closure) { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(PeerConnectionCtx::isActive()); + + for (auto& idAndPc : GetInstance()->mPeerConnections) { + if (!idAndPc.second->IsClosed()) { + idAndPc.second->GetStats(nullptr, true) + ->Then( + GetMainThreadSerialEventTarget(), __func__, + [=](UniquePtr<dom::RTCStatsReportInternal>&& aReport) { + if (PeerConnectionCtx::isActive()) { + PeerConnectionCtx::GetInstance()->DeliverStats( + std::move(aReport)); + } + }, + [=](nsresult aError) {}); + idAndPc.second->CollectConduitTelemetryData(); + } + } +} + +void PeerConnectionCtx::UpdateNetworkState(bool online) { + auto ctx = GetInstance(); + if (ctx->mPeerConnections.empty()) { + return; + } + for (auto pc : ctx->mPeerConnections) { + pc.second->UpdateNetworkState(online); + } +} + +SharedWebrtcState* PeerConnectionCtx::GetSharedWebrtcState() const { + MOZ_ASSERT(NS_IsMainThread()); + return mSharedWebrtcState; +} + +void PeerConnectionCtx::RemovePeerConnection(const std::string& aKey) { + MOZ_ASSERT(NS_IsMainThread()); + auto it = mPeerConnections.find(aKey); + if (it != mPeerConnections.end()) { + if (it->second->GetFinalStats() && !it->second->LongTermStatsIsDisabled()) { + WebrtcGlobalInformation::StashStats(*(it->second->GetFinalStats())); + } + nsAutoString pcId = NS_ConvertASCIItoUTF16(it->second->GetName().c_str()); + if (XRE_IsContentProcess()) { + if (auto* child = WebrtcGlobalChild::Get(); child) { + auto pcId = NS_ConvertASCIItoUTF16(it->second->GetName().c_str()); + child->SendPeerConnectionFinalStats(*(it->second->GetFinalStats())); + child->SendPeerConnectionDestroyed(pcId); + } + } else { + using Update = WebrtcGlobalInformation::PcTrackingUpdate; + auto update = Update::Remove(pcId); + auto finalStats = + MakeUnique<RTCStatsReportInternal>(*(it->second->GetFinalStats())); + WebrtcGlobalStatsHistory::Record(std::move(finalStats)); + WebrtcGlobalInformation::PeerConnectionTracking(update); + } + + mPeerConnections.erase(it); + if (mPeerConnections.empty()) { + mSharedWebrtcState = nullptr; + StopTelemetryTimer(); + } + } +} + +void PeerConnectionCtx::AddPeerConnection(const std::string& aKey, + PeerConnectionImpl* aPeerConnection) { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(mPeerConnections.count(aKey) == 0, + "PeerConnection with this key should not already exist"); + if (mPeerConnections.empty()) { + AudioState::Config audioStateConfig; + audioStateConfig.audio_mixer = new rtc::RefCountedObject<DummyAudioMixer>(); + AudioProcessingBuilder audio_processing_builder; + audioStateConfig.audio_processing = + new rtc::RefCountedObject<DummyAudioProcessing>(); + audioStateConfig.audio_device_module = + new rtc::RefCountedObject<FakeAudioDeviceModule>(); + + SharedThreadPoolWebRtcTaskQueueFactory taskQueueFactory; + constexpr bool supportTailDispatch = true; + // Note the NonBlocking DeletionPolicy! + // This task queue is passed into libwebrtc as a raw pointer. + // WebrtcCallWrapper guarantees that it outlives its webrtc::Call instance. + // Outside of libwebrtc we must use ref-counting to either the + // WebrtcCallWrapper or to the CallWorkerThread to keep it alive. + auto callWorkerThread = + WrapUnique(taskQueueFactory + .CreateTaskQueueWrapper<DeletionPolicy::NonBlocking>( + "CallWorker", supportTailDispatch, + webrtc::TaskQueueFactory::Priority::NORMAL, + MediaThreadType::WEBRTC_CALL_THREAD) + .release()); + + UniquePtr<webrtc::WebRtcKeyValueConfig> trials = + WrapUnique(new NoTrialsConfig()); + + mSharedWebrtcState = MakeAndAddRef<SharedWebrtcState>( + new CallWorkerThread(std::move(callWorkerThread)), + std::move(audioStateConfig), + already_AddRefed(CreateBuiltinAudioDecoderFactory().release()), + std::move(trials)); + StartTelemetryTimer(); + } + auto pcId = NS_ConvertASCIItoUTF16(aPeerConnection->GetName().c_str()); + if (XRE_IsContentProcess()) { + if (auto* child = WebrtcGlobalChild::Get(); child) { + child->SendPeerConnectionCreated( + pcId, aPeerConnection->LongTermStatsIsDisabled()); + } + } else { + using Update = WebrtcGlobalInformation::PcTrackingUpdate; + auto update = Update::Add(pcId, aPeerConnection->LongTermStatsIsDisabled()); + WebrtcGlobalInformation::PeerConnectionTracking(update); + } + mPeerConnections[aKey] = aPeerConnection; +} + +PeerConnectionImpl* PeerConnectionCtx::GetPeerConnection( + const std::string& aKey) const { + MOZ_ASSERT(NS_IsMainThread()); + auto iterator = mPeerConnections.find(aKey); + if (iterator == mPeerConnections.end()) { + return nullptr; + } + return iterator->second; +} + +void PeerConnectionCtx::ClearClosedStats() { + for (auto& [id, pc] : mPeerConnections) { + Unused << id; + if (pc->IsClosed()) { + // Rare case + pc->DisableLongTermStats(); + } + } +} + +nsresult PeerConnectionCtx::Initialize() { + MOZ_ASSERT(NS_IsMainThread()); + initGMP(); + SdpRidAttributeList::kMaxRidLength = + webrtc::BaseRtpStringExtension::kMaxValueSizeBytes; + + if (XRE_IsContentProcess()) { + WebrtcGlobalChild::Get(); + } + + return NS_OK; +} + +nsresult PeerConnectionCtx::StartTelemetryTimer() { + return NS_NewTimerWithFuncCallback(getter_AddRefs(mTelemetryTimer), + EverySecondTelemetryCallback_m, this, 1000, + nsITimer::TYPE_REPEATING_PRECISE_CAN_SKIP, + "EverySecondTelemetryCallback_m"); +} + +void PeerConnectionCtx::StopTelemetryTimer() { + if (mTelemetryTimer) { + mTelemetryTimer->Cancel(); + mTelemetryTimer = nullptr; + } +} + +static void GMPReady_m() { + if (PeerConnectionCtx::isActive()) { + PeerConnectionCtx::GetInstance()->onGMPReady(); + } +}; + +static void GMPReady() { + GetMainThreadSerialEventTarget()->Dispatch(WrapRunnableNM(&GMPReady_m), + NS_DISPATCH_NORMAL); +}; + +void PeerConnectionCtx::initGMP() { + mGMPService = do_GetService("@mozilla.org/gecko-media-plugin-service;1"); + + if (!mGMPService) { + CSFLogError(LOGTAG, "%s failed to get the gecko-media-plugin-service", + __FUNCTION__); + return; + } + + nsCOMPtr<nsIThread> thread; + nsresult rv = mGMPService->GetThread(getter_AddRefs(thread)); + + if (NS_FAILED(rv)) { + mGMPService = nullptr; + CSFLogError(LOGTAG, + "%s failed to get the gecko-media-plugin thread, err=%u", + __FUNCTION__, static_cast<unsigned>(rv)); + return; + } + + // presumes that all GMP dir scans have been queued for the GMPThread + thread->Dispatch(WrapRunnableNM(&GMPReady), NS_DISPATCH_NORMAL); +} + +nsresult PeerConnectionCtx::Cleanup() { + CSFLogDebug(LOGTAG, "%s", __FUNCTION__); + MOZ_ASSERT(NS_IsMainThread()); + + mQueuedJSEPOperations.Clear(); + mGMPService = nullptr; + mTransportHandler = nullptr; + for (auto& [id, pc] : mPeerConnections) { + (void)id; + pc->Close(); + } + mPeerConnections.clear(); + mSharedWebrtcState = nullptr; + return NS_OK; +} + +void PeerConnectionCtx::queueJSEPOperation(nsIRunnable* aOperation) { + mQueuedJSEPOperations.AppendElement(aOperation); +} + +void PeerConnectionCtx::onGMPReady() { + mGMPReady = true; + for (size_t i = 0; i < mQueuedJSEPOperations.Length(); ++i) { + mQueuedJSEPOperations[i]->Run(); + } + mQueuedJSEPOperations.Clear(); +} + +bool PeerConnectionCtx::gmpHasH264() { + if (!mGMPService) { + return false; + } + + // XXX I'd prefer if this was all known ahead of time... + + AutoTArray<nsCString, 1> tags; + tags.AppendElement("h264"_ns); + + bool has_gmp; + nsresult rv; + rv = mGMPService->HasPluginForAPI(nsLiteralCString(GMP_API_VIDEO_ENCODER), + tags, &has_gmp); + if (NS_FAILED(rv) || !has_gmp) { + return false; + } + + rv = mGMPService->HasPluginForAPI(nsLiteralCString(GMP_API_VIDEO_DECODER), + tags, &has_gmp); + if (NS_FAILED(rv) || !has_gmp) { + return false; + } + + return true; +} + +} // namespace mozilla diff --git a/dom/media/webrtc/jsapi/PeerConnectionCtx.h b/dom/media/webrtc/jsapi/PeerConnectionCtx.h new file mode 100644 index 0000000000..fdd81f6406 --- /dev/null +++ b/dom/media/webrtc/jsapi/PeerConnectionCtx.h @@ -0,0 +1,194 @@ +/* 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/. */ + +#ifndef peerconnectionctx_h___h__ +#define peerconnectionctx_h___h__ + +#include <map> +#include <string> + +#include "WebrtcGlobalChild.h" +#include "api/field_trials_view.h" +#include "api/scoped_refptr.h" +#include "call/audio_state.h" +#include "MediaTransportHandler.h" // Mostly for IceLogPromise +#include "mozIGeckoMediaPluginService.h" +#include "mozilla/Attributes.h" +#include "mozilla/StaticPtr.h" +#include "nsIRunnable.h" +#include "PeerConnectionImpl.h" + +namespace webrtc { +class AudioDecoderFactory; + +// Used for testing in mediapipeline_unittest.cpp, MockCall.h +class NoTrialsConfig : public FieldTrialsView { + public: + NoTrialsConfig() = default; + std::string Lookup(absl::string_view key) const override { + // Upstream added a new default field trial string for + // CongestionWindow, that we don't want. In + // third_party/libwebrtc/rtc_base/experiments/rate_control_settings.cc + // they set kCongestionWindowDefaultFieldTrialString to + // "QueueSize:350,MinBitrate:30000,DropFrame:true". With QueueSize + // set, GoogCcNetworkController::UpdateCongestionWindowSize is + // called. Because negative values are calculated in + // feedback_rtt, an assert fires when calculating data_window in + // GoogCcNetworkController::UpdateCongestionWindowSize. We probably + // need to figure out why we're calculating negative feedback_rtt. + // See Bug 1780620. + if ("WebRTC-CongestionWindow" == key) { + return std::string("MinBitrate:30000,DropFrame:true"); + } + return std::string(); + } +}; +} // namespace webrtc + +namespace mozilla { +class PeerConnectionCtxObserver; + +namespace dom { +class WebrtcGlobalInformation; +} + +/** + * Refcounted class containing state shared across all PeerConnections and all + * Call instances. Managed by PeerConnectionCtx, and kept around while there are + * registered peer connections. + */ +class SharedWebrtcState { + public: + NS_INLINE_DECL_THREADSAFE_REFCOUNTING(SharedWebrtcState) + + SharedWebrtcState(RefPtr<AbstractThread> aCallWorkerThread, + webrtc::AudioState::Config&& aAudioStateConfig, + RefPtr<webrtc::AudioDecoderFactory> aAudioDecoderFactory, + UniquePtr<webrtc::FieldTrialsView> aTrials); + + // A global Call worker thread shared between all Call instances. Implements + // AbstractThread for running tasks that call into a Call instance through its + // webrtc::TaskQueue member, and for using AbstractThread-specific higher + // order constructs like StateMirroring. + const RefPtr<AbstractThread> mCallWorkerThread; + + // AudioState config containing dummy implementations of the audio stack, + // since we use our own audio stack instead. Shared across all Call instances. + const webrtc::AudioState::Config mAudioStateConfig; + + // AudioDecoderFactory instance shared between calls, to limit the number of + // instances in large calls. + const RefPtr<webrtc::AudioDecoderFactory> mAudioDecoderFactory; + + // Trials instance shared between calls, to limit the number of instances in + // large calls. + const UniquePtr<webrtc::FieldTrialsView> mTrials; + + private: + virtual ~SharedWebrtcState(); +}; + +// A class to hold some of the singleton objects we need: +// * The global PeerConnectionImpl table and its associated lock. +// * Stats report objects for PCs that are gone +// * GMP related state +// * Upstream webrtc state shared across all Calls (processing thread) +class PeerConnectionCtx { + public: + static nsresult InitializeGlobal(); + static PeerConnectionCtx* GetInstance(); + static bool isActive(); + static void Destroy(); + + bool isReady() { + // If mGMPService is not set, we aren't using GMP. + if (mGMPService) { + return mGMPReady; + } + return true; + } + + void queueJSEPOperation(nsIRunnable* aJSEPOperation); + void onGMPReady(); + + bool gmpHasH264(); + + static void UpdateNetworkState(bool online); + + RefPtr<MediaTransportHandler> GetTransportHandler() const { + return mTransportHandler; + } + + SharedWebrtcState* GetSharedWebrtcState() const; + + void RemovePeerConnection(const std::string& aKey); + void AddPeerConnection(const std::string& aKey, + PeerConnectionImpl* aPeerConnection); + PeerConnectionImpl* GetPeerConnection(const std::string& aKey) const; + template <typename Function> + void ForEachPeerConnection(Function&& aFunction) const { + MOZ_ASSERT(NS_IsMainThread()); + for (const auto& pair : mPeerConnections) { + aFunction(pair.second); + } + } + + void ClearClosedStats(); + + private: + std::map<const std::string, PeerConnectionImpl*> mPeerConnections; + + PeerConnectionCtx() + : mGMPReady(false), + mTransportHandler( + MediaTransportHandler::Create(GetMainThreadSerialEventTarget())) {} + + // This is a singleton, so don't copy construct it, etc. + PeerConnectionCtx(const PeerConnectionCtx& other) = delete; + void operator=(const PeerConnectionCtx& other) = delete; + virtual ~PeerConnectionCtx() = default; + + nsresult Initialize(); + nsresult StartTelemetryTimer(); + void StopTelemetryTimer(); + nsresult Cleanup(); + + void initGMP(); + + static void EverySecondTelemetryCallback_m(nsITimer* timer, void*); + + nsCOMPtr<nsITimer> mTelemetryTimer; + + private: + void DeliverStats(UniquePtr<dom::RTCStatsReportInternal>&& aReport); + + std::map<nsString, UniquePtr<dom::RTCStatsReportInternal>> mLastReports; + // We cannot form offers/answers properly until the Gecko Media Plugin stuff + // has been initted, which is a complicated mess of thread dispatches, + // including sync dispatches to main. So, we need to be able to queue up + // offer creation (or SetRemote, when we're the answerer) until all of this is + // ready to go, since blocking on this init is just begging for deadlock. + nsCOMPtr<mozIGeckoMediaPluginService> mGMPService; + bool mGMPReady; + nsTArray<nsCOMPtr<nsIRunnable>> mQueuedJSEPOperations; + + // Not initted, just for ICE logging stuff + RefPtr<MediaTransportHandler> mTransportHandler; + + // State used by libwebrtc that needs to be shared across all PeerConnections + // and all Call instances. Set while there is at least one peer connection + // registered. CallWrappers can hold a ref to this object to be sure members + // are alive long enough. + RefPtr<SharedWebrtcState> mSharedWebrtcState; + + static PeerConnectionCtx* gInstance; + + public: + static mozilla::StaticRefPtr<mozilla::PeerConnectionCtxObserver> + gPeerConnectionCtxObserver; +}; + +} // namespace mozilla + +#endif diff --git a/dom/media/webrtc/jsapi/PeerConnectionImpl.cpp b/dom/media/webrtc/jsapi/PeerConnectionImpl.cpp new file mode 100644 index 0000000000..567b682b2a --- /dev/null +++ b/dom/media/webrtc/jsapi/PeerConnectionImpl.cpp @@ -0,0 +1,4640 @@ +/* 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 "jsapi/RTCRtpReceiver.h" +#include "jsapi/RTCRtpSender.h" + +#include "mozilla/IntegerPrintfMacros.h" +#include "mozilla/Sprintf.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 "nsGlobalWindow.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), + mJsConfiguration(), + 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), + mDtmfEnabled(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); + + // media.peerconnection.dtmf.enabled controls both sdp generation for + // DTMF support as well as DTMF exposure to DOM + branch->GetBoolPref("media.peerconnection.dtmf.enabled", &mDtmfEnabled); + } + + 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 = mDtmfEnabled; + } + } 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; + bool mDtmfEnabled; +}; + +class ConfigureRedCodec { + public: + explicit ConfigureRedCodec(nsCOMPtr<nsIPrefBranch>& branch, + std::vector<uint8_t>* redundantEncodings) + : mRedundantEncodings(redundantEncodings) { + // if we wanted to override or modify which encodings are considered + // for redundant encodings, we'd probably want to handle it here by + // checking prefs modifying the operator() code below + } + + void operator()(UniquePtr<JsepCodecDescription>& codec) const { + if (codec->Type() == SdpMediaSection::kVideo && !codec->mEnabled) { + uint8_t pt = (uint8_t)strtoul(codec->mDefaultPt.c_str(), nullptr, 10); + // don't search for the codec payload type unless we have a valid + // conversion (non-zero) + if (pt != 0) { + std::vector<uint8_t>::iterator it = std::find( + mRedundantEncodings->begin(), mRedundantEncodings->end(), pt); + if (it != mRedundantEncodings->end()) { + mRedundantEncodings->erase(it); + } + } + } + } + + private: + std::vector<uint8_t>* mRedundantEncodings; +}; + +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); + + // if red codec is enabled, configure it for the other enabled codecs + for (auto& codec : mJsepSession->Codecs()) { + if (codec->mName == "red" && codec->mEnabled) { + JsepVideoCodecDescription* redCodec = + static_cast<JsepVideoCodecDescription*>(codec.get()); + ConfigureRedCodec configureRed(branch, &(redCodec->mRedundantEncodings)); + mJsepSession->ForEachCodec(configureRed); + break; + } + } + + // 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 = + mWindow ? mWindow->EventTargetFor(TaskCategory::Other) : nullptr; + 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; + DataChannelConnection::Type theType = + static_cast<DataChannelConnection::Type>(aType); + + 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), theType, + ordered, + aType == DataChannelConnection::PARTIAL_RELIABLE_REXMIT + ? aMaxNum + : (aType == DataChannelConnection::PARTIAL_RELIABLE_TIMED ? 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) { + 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); + } + UpdateConnectionState(); +} + +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 any RTCIceTransports are + // in the "failed" state or any RTCDtlsTransports are in the "failed" state. + // NOTE: "any RTCIceTransports are in the failed state" is equivalent to + // mIceConnectionState == Failed + if (mIceConnectionState == RTCIceConnectionState::Failed || + statesFound.count(RTCDtlsTransportState::Failed)) { + return RTCPeerConnectionState::Failed; + } + + // disconnected None of the previous states apply and any + // RTCIceTransports are in the "disconnected" state. + // NOTE: "any RTCIceTransports are in the disconnected state" is equivalent to + // mIceConnectionState == Disconnected. + if (mIceConnectionState == RTCIceConnectionState::Disconnected) { + return RTCPeerConnectionState::Disconnected; + } + + // new None of the previous states apply and all RTCIceTransports are + // in the "new" or "closed" state, and all RTCDtlsTransports are in the "new" + // or "closed" state, or there are no transports. + // NOTE: "all RTCIceTransports are in the new or closed state" is equivalent + // to mIceConnectionState == New. + if (mIceConnectionState == RTCIceConnectionState::New && + !statesFound.count(RTCDtlsTransportState::Connecting) && + !statesFound.count(RTCDtlsTransportState::Connected) && + !statesFound.count(RTCDtlsTransportState::Failed)) { + return RTCPeerConnectionState::New; + } + + // No transports + if (statesFound.empty()) { + return RTCPeerConnectionState::New; + } + + // connecting None of the previous states apply and any + // RTCIceTransport is in the "new" or "checking" state or any + // RTCDtlsTransport is in the "new" or "connecting" state. + // NOTE: "None of the previous states apply and any RTCIceTransport is in the + // "new" or "checking" state" is equivalent to mIceConnectionState == + // Checking. + if (mIceConnectionState == RTCIceConnectionState::Checking || + statesFound.count(RTCDtlsTransportState::New) || + statesFound.count(RTCDtlsTransportState::Connecting)) { + return RTCPeerConnectionState::Connecting; + } + + // connected None of the previous states apply and all RTCIceTransports are + // in the "connected", "completed" or "closed" state, and all + // RTCDtlsTransports are in the "connected" or "closed" state. + // NOTE: "None of the previous states apply and all RTCIceTransports are in + // the "connected", "completed" or "closed" state" is equivalent to + // mIceConnectionState == Connected. + if (mIceConnectionState == RTCIceConnectionState::Connected && + !statesFound.count(RTCDtlsTransportState::New) && + !statesFound.count(RTCDtlsTransportState::Failed) && + !statesFound.count(RTCDtlsTransportState::Connecting)) { + return RTCPeerConnectionState::Connected; + } + + // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + // THERE IS NO CATCH-ALL NONE-OF-THE-ABOVE IN THE SPEC! THIS IS REALLY BAD! !! + // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + + // Let's try to figure out how bad, precisely. + // Any one of these will cause us to bail above. + MOZ_ASSERT(mIceConnectionState != RTCIceConnectionState::Failed && + mIceConnectionState != RTCIceConnectionState::Disconnected && + mIceConnectionState != RTCIceConnectionState::Checking); + MOZ_ASSERT(!statesFound.count(RTCDtlsTransportState::New) && + !statesFound.count(RTCDtlsTransportState::Connecting) && + !statesFound.count(RTCDtlsTransportState::Failed)); + + // One of these must be set, or the empty() check would have failed above. + MOZ_ASSERT(statesFound.count(RTCDtlsTransportState::Connected) || + statesFound.count(RTCDtlsTransportState::Closed)); + + // Here are our remaining possibilities: + // ICE connected, !statesFound.count(Connected), statesFound.count(Closed) + // ICE connected, statesFound.count(Connected), !statesFound.count(Closed) + // ICE connected, statesFound.count(Connected), statesFound.count(Closed) + // All three of these would result in returning Connected above. + + // ICE new, !statesFound.count(Connected), statesFound.count(Closed) + // This results in returning New above. Whew. + + // ICE new, statesFound.count(Connected), !statesFound.count(Closed) + // ICE new, statesFound.count(Connected), statesFound.count(Closed) + // These would make it all the way here! Very weird state though, for all + // ICE transports to be new/closed, but having a connected DTLS transport. + // Handle this as a non-transition, just in case. + return mConnectionState; +} + +void 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) { + JSErrorResult jrv; + mPCObserver->OnStateChange(PCObserverStateType::ConnectionState, jrv); + } + } +} + +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; + } + + JS::Rooted<JSObject*> jsobj( + jsapi.cx(), + JS::NewArrayBufferWithContents(jsapi.cx(), size, packet.release())); + + 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); + + // 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 default (ulpfec and red). + if (codec->mName == "webrtc-datachannel" || codec->mName == "ulpfec" || + codec->mName == "red") { + 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); + + // With red update the redundant encodings list + for (auto& videoCodec : aPreferredCodecs) { + if (videoCodec->mName == "red") { + JsepVideoCodecDescription& red = + static_cast<JsepVideoCodecDescription&>(*videoCodec); + red.UpdateRedundantEncodings(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 std::string& 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()); + 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; + EventDispatcher::DispatchDOMEvent(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()); + } + } + + 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 (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(); + } + + // Spec does not actually tell us to do this, but that is probably a + // spec bug. + UpdateConnectionState(); + + JSErrorResult jrv; + if (newSignalingState != mSignalingState) { + mSignalingState = newSignalingState; + mPCObserver->OnStateChange(PCObserverStateType::SignalingState, jrv); + } + + if (aRemote) { + dom::RTCRtpReceiver::StreamAssociationChanges changes; + for (const auto& transceiver : mTransceivers) { + transceiver->Receiver()->UpdateStreams(&changes); + } + + 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); + } + } + + // 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; + } + } + + 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); + } + } + mPCObserver->FireTrackEvent(*trackEvent.mReceiver, streams, jrv); + } + + // TODO(Bug 1241291): Legacy event, remove eventually + for (const auto& stream : newStreams) { + mPCObserver->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!"); + } + + WrappableJSErrorResult rv; + mPCObserver->OnStateChange(PCObserverStateType::IceConnectionState, rv); + UpdateConnectionState(); +} + +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) { + std::ostringstream ss; + ss << fingerprint.hashFunc; + digests.emplace_back(ss.str(), 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()) { + 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); +} + +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()); + } + + 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); +} + +/** + * 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); + + Maybe<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 diff --git a/dom/media/webrtc/jsapi/PeerConnectionImpl.h b/dom/media/webrtc/jsapi/PeerConnectionImpl.h new file mode 100644 index 0000000000..66af1aa0e9 --- /dev/null +++ b/dom/media/webrtc/jsapi/PeerConnectionImpl.h @@ -0,0 +1,969 @@ +/* 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/. */ + +#ifndef _PEER_CONNECTION_IMPL_H_ +#define _PEER_CONNECTION_IMPL_H_ + +#include <string> +#include <vector> +#include <map> +#include <cmath> + +#include "prlock.h" +#include "mozilla/RefPtr.h" +#include "nsComponentManagerUtils.h" +#include "nsPIDOMWindow.h" +#include "nsIUUIDGenerator.h" +#include "nsIThread.h" +#include "mozilla/Mutex.h" +#include "mozilla/Attributes.h" + +// Work around nasty macro in webrtc/voice_engine/voice_engine_defines.h +#ifdef GetLastError +# undef GetLastError +#endif + +#include "jsep/JsepSession.h" +#include "jsep/JsepSessionImpl.h" +#include "sdp/SdpMediaSection.h" + +#include "mozilla/ErrorResult.h" +#include "jsapi/PacketDumper.h" +#include "mozilla/dom/RTCPeerConnectionBinding.h" // mozPacketDumpType, maybe move? +#include "mozilla/dom/PeerConnectionImplBinding.h" // ChainedOperation +#include "mozilla/dom/RTCRtpCapabilitiesBinding.h" +#include "mozilla/dom/RTCRtpTransceiverBinding.h" +#include "mozilla/dom/RTCConfigurationBinding.h" +#include "PrincipalChangeObserver.h" +#include "mozilla/dom/PromiseNativeHandler.h" + +#include "mozilla/TimeStamp.h" +#include "mozilla/net/DataChannel.h" +#include "VideoUtils.h" +#include "VideoSegment.h" +#include "mozilla/dom/RTCStatsReportBinding.h" +#include "mozilla/PeerIdentity.h" +#include "RTCStatsIdGenerator.h" +#include "RTCStatsReport.h" + +#include "mozilla/net/StunAddrsRequestChild.h" +#include "MediaTransportHandler.h" +#include "nsIHttpChannelInternal.h" +#include "RTCDtlsTransport.h" +#include "RTCRtpTransceiver.h" + +namespace test { +#ifdef USE_FAKE_PCOBSERVER +class AFakePCObserver; +#endif +} // namespace test + +class nsDOMDataChannel; +class nsIPrincipal; + +namespace mozilla { +struct CandidateInfo; +class DataChannel; +class DtlsIdentity; +class MediaPipeline; +class MediaPipelineReceive; +class MediaPipelineTransmit; +enum class PrincipalPrivacy : uint8_t; +class SharedWebrtcState; + +namespace dom { +class RTCCertificate; +struct RTCConfiguration; +struct RTCRtpSourceEntry; +struct RTCIceServer; +struct RTCOfferOptions; +struct RTCRtpParameters; +class RTCRtpSender; +class MediaStreamTrack; + +#ifdef USE_FAKE_PCOBSERVER +typedef test::AFakePCObserver PeerConnectionObserver; +typedef const char* PCObserverString; +#else +class PeerConnectionObserver; +typedef NS_ConvertUTF8toUTF16 PCObserverString; +#endif +} // namespace dom +} // namespace mozilla + +#if defined(__cplusplus) && __cplusplus >= 201103L +typedef struct Timecard Timecard; +#else +# include "common/time_profiling/timecard.h" +#endif + +// To preserve blame, convert nsresult to ErrorResult with wrappers. These +// macros help declare wrappers w/function being wrapped when there are no +// differences. + +#define NS_IMETHODIMP_TO_ERRORRESULT(func, rv, ...) \ + NS_IMETHODIMP func(__VA_ARGS__); \ + void func(__VA_ARGS__, rv) + +#define NS_IMETHODIMP_TO_ERRORRESULT_RETREF(resulttype, func, rv, ...) \ + NS_IMETHODIMP func(__VA_ARGS__, resulttype** result); \ + already_AddRefed<resulttype> func(__VA_ARGS__, rv) + +namespace mozilla { + +using mozilla::DtlsIdentity; +using mozilla::ErrorResult; +using mozilla::PeerIdentity; +using mozilla::dom::PeerConnectionObserver; +using mozilla::dom::RTCConfiguration; +using mozilla::dom::RTCIceServer; +using mozilla::dom::RTCOfferOptions; + +class PeerConnectionWrapper; +class RemoteSourceStreamInfo; + +// Uuid Generator +class PCUuidGenerator : public mozilla::JsepUuidGenerator { + public: + virtual bool Generate(std::string* idp) override; + virtual mozilla::JsepUuidGenerator* Clone() const override { + return new PCUuidGenerator(*this); + } + + private: + nsCOMPtr<nsIUUIDGenerator> mGenerator; +}; + +// This is a variation of Telemetry::AutoTimer that keeps a reference +// count and records the elapsed time when the count falls to zero. The +// elapsed time is recorded in seconds. +struct PeerConnectionAutoTimer { + PeerConnectionAutoTimer() + : mRefCnt(0), mStart(TimeStamp::Now()), mUsedAV(false){}; + void RegisterConnection(); + void UnregisterConnection(bool aContainedAV); + bool IsStopped(); + + private: + int64_t mRefCnt; + TimeStamp mStart; + bool mUsedAV; +}; + +// Enter an API call and check that the state is OK, +// the PC isn't closed, etc. +#define PC_AUTO_ENTER_API_CALL(assert_ice_ready) \ + do { \ + /* do/while prevents res from conflicting with locals */ \ + nsresult res = CheckApiState(assert_ice_ready); \ + if (NS_FAILED(res)) return res; \ + } while (0) +#define PC_AUTO_ENTER_API_CALL_VOID_RETURN(assert_ice_ready) \ + do { \ + /* do/while prevents res from conflicting with locals */ \ + nsresult res = CheckApiState(assert_ice_ready); \ + if (NS_FAILED(res)) return; \ + } while (0) +#define PC_AUTO_ENTER_API_CALL_NO_CHECK() CheckThread() + +class PeerConnectionImpl final + : public nsISupports, + public nsWrapperCache, + public mozilla::DataChannelConnection::DataConnectionListener { + struct Internal; // Avoid exposing c includes to bindings + + public: + explicit PeerConnectionImpl( + const mozilla::dom::GlobalObject* aGlobal = nullptr); + + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + NS_DECL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(PeerConnectionImpl) + + struct RtpExtensionHeader { + JsepMediaType mMediaType; + SdpDirectionAttribute::Direction direction; + std::string extensionname; + }; + + JSObject* WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) override; + nsPIDOMWindowInner* GetParentObject() const; + + static already_AddRefed<PeerConnectionImpl> Constructor( + const mozilla::dom::GlobalObject& aGlobal); + + // DataConnection observers + void NotifyDataChannel(already_AddRefed<mozilla::DataChannel> aChannel) + // PeerConnectionImpl only inherits from mozilla::DataChannelConnection + // inside libxul. + override; + + void NotifyDataChannelOpen(DataChannel*) override; + + void NotifyDataChannelClosed(DataChannel*) override; + + void NotifySctpConnected() override; + + void NotifySctpClosed() override; + + const RefPtr<MediaTransportHandler> GetTransportHandler() const; + + // Handle system to allow weak references to be passed through C code + virtual const std::string& GetHandle(); + + // Name suitable for exposing to content + virtual const std::string& GetName(); + + // ICE events + void IceConnectionStateChange(dom::RTCIceConnectionState state); + void IceGatheringStateChange(dom::RTCIceGatheringState state); + void OnCandidateFound(const std::string& aTransportId, + const CandidateInfo& aCandidateInfo); + void UpdateDefaultCandidate(const std::string& defaultAddr, + uint16_t defaultPort, + const std::string& defaultRtcpAddr, + uint16_t defaultRtcpPort, + const std::string& transportId); + + static void ListenThread(void* aData); + static void ConnectThread(void* aData); + + // Get the STS thread + nsISerialEventTarget* GetSTSThread() { + PC_AUTO_ENTER_API_CALL_NO_CHECK(); + return mSTSThread; + } + + nsresult Initialize(PeerConnectionObserver& aObserver, + nsGlobalWindowInner* aWindow); + + // Initialize PeerConnection from an RTCConfiguration object (JS entrypoint) + void Initialize(PeerConnectionObserver& aObserver, + nsGlobalWindowInner& aWindow, ErrorResult& rv); + + void SetCertificate(mozilla::dom::RTCCertificate& aCertificate); + const RefPtr<mozilla::dom::RTCCertificate>& Certificate() const; + // This is a hack to support external linkage. + RefPtr<DtlsIdentity> Identity() const; + + NS_IMETHODIMP_TO_ERRORRESULT(CreateOffer, ErrorResult& rv, + const RTCOfferOptions& aOptions) { + rv = CreateOffer(aOptions); + } + + NS_IMETHODIMP CreateAnswer(); + void CreateAnswer(ErrorResult& rv) { rv = CreateAnswer(); } + + NS_IMETHODIMP CreateOffer(const mozilla::JsepOfferOptions& aConstraints); + + NS_IMETHODIMP SetLocalDescription(int32_t aAction, const char* aSDP); + + void SetLocalDescription(int32_t aAction, const nsAString& aSDP, + ErrorResult& rv) { + rv = SetLocalDescription(aAction, NS_ConvertUTF16toUTF8(aSDP).get()); + } + + NS_IMETHODIMP SetRemoteDescription(int32_t aAction, const char* aSDP); + + void SetRemoteDescription(int32_t aAction, const nsAString& aSDP, + ErrorResult& rv) { + rv = SetRemoteDescription(aAction, NS_ConvertUTF16toUTF8(aSDP).get()); + } + + already_AddRefed<dom::Promise> GetStats(dom::MediaStreamTrack* aSelector); + + void GetRemoteStreams(nsTArray<RefPtr<DOMMediaStream>>& aStreamsOut) const; + + NS_IMETHODIMP AddIceCandidate(const char* aCandidate, const char* aMid, + const char* aUfrag, + const dom::Nullable<unsigned short>& aLevel); + + void AddIceCandidate(const nsAString& aCandidate, const nsAString& aMid, + const nsAString& aUfrag, + const dom::Nullable<unsigned short>& aLevel, + ErrorResult& rv) { + rv = AddIceCandidate(NS_ConvertUTF16toUTF8(aCandidate).get(), + NS_ConvertUTF16toUTF8(aMid).get(), + NS_ConvertUTF16toUTF8(aUfrag).get(), aLevel); + } + + void UpdateNetworkState(bool online); + + NS_IMETHODIMP CloseStreams(); + + void CloseStreams(ErrorResult& rv) { rv = CloseStreams(); } + + already_AddRefed<dom::RTCRtpTransceiver> AddTransceiver( + const dom::RTCRtpTransceiverInit& aInit, const nsAString& aKind, + dom::MediaStreamTrack* aSendTrack, bool aAddTrackMagic, ErrorResult& aRv); + + bool CheckNegotiationNeeded(); + bool CreatedSender(const dom::RTCRtpSender& aSender) const; + + // test-only + NS_IMETHODIMP_TO_ERRORRESULT(EnablePacketDump, ErrorResult& rv, + unsigned long level, dom::mozPacketDumpType type, + bool sending) { + rv = EnablePacketDump(level, type, sending); + } + + // test-only + NS_IMETHODIMP_TO_ERRORRESULT(DisablePacketDump, ErrorResult& rv, + unsigned long level, dom::mozPacketDumpType type, + bool sending) { + rv = DisablePacketDump(level, type, sending); + } + + void GetPeerIdentity(nsAString& peerIdentity) { + if (mPeerIdentity) { + peerIdentity = mPeerIdentity->ToString(); + return; + } + + peerIdentity.SetIsVoid(true); + } + + const PeerIdentity* GetPeerIdentity() const { return mPeerIdentity; } + NS_IMETHODIMP_TO_ERRORRESULT(SetPeerIdentity, ErrorResult& rv, + const nsAString& peerIdentity) { + rv = SetPeerIdentity(peerIdentity); + } + + const std::string& GetIdAsAscii() const { return mName; } + + void GetId(nsAString& id) { id = NS_ConvertASCIItoUTF16(mName.c_str()); } + + void SetId(const nsAString& id) { mName = NS_ConvertUTF16toUTF8(id).get(); } + + // this method checks to see if we've made a promise to protect media. + bool PrivacyRequested() const { + return mRequestedPrivacy.valueOr(PrincipalPrivacy::NonPrivate) == + PrincipalPrivacy::Private; + } + + NS_IMETHODIMP GetFingerprint(char** fingerprint); + void GetFingerprint(nsAString& fingerprint) { + char* tmp; + nsresult rv = GetFingerprint(&tmp); + NS_ENSURE_SUCCESS_VOID(rv); + fingerprint.AssignASCII(tmp); + delete[] tmp; + } + + void GetCurrentLocalDescription(nsAString& aSDP) const; + void GetPendingLocalDescription(nsAString& aSDP) const; + + void GetCurrentRemoteDescription(nsAString& aSDP) const; + void GetPendingRemoteDescription(nsAString& aSDP) const; + + dom::Nullable<bool> GetCurrentOfferer() const; + dom::Nullable<bool> GetPendingOfferer() const; + + NS_IMETHODIMP SignalingState(mozilla::dom::RTCSignalingState* aState); + + mozilla::dom::RTCSignalingState SignalingState() { + mozilla::dom::RTCSignalingState state; + SignalingState(&state); + return state; + } + + NS_IMETHODIMP IceConnectionState(mozilla::dom::RTCIceConnectionState* aState); + + mozilla::dom::RTCIceConnectionState IceConnectionState() { + mozilla::dom::RTCIceConnectionState state; + IceConnectionState(&state); + return state; + } + + NS_IMETHODIMP IceGatheringState(mozilla::dom::RTCIceGatheringState* aState); + + mozilla::dom::RTCIceGatheringState IceGatheringState() { + return mIceGatheringState; + } + + NS_IMETHODIMP ConnectionState(mozilla::dom::RTCPeerConnectionState* aState); + + mozilla::dom::RTCPeerConnectionState ConnectionState() { + mozilla::dom::RTCPeerConnectionState state; + ConnectionState(&state); + return state; + } + + NS_IMETHODIMP Close(); + + void Close(ErrorResult& rv) { rv = Close(); } + + // TODO: Convert this to MOZ_CAN_RUN_SCRIPT (bug 1415230) + MOZ_CAN_RUN_SCRIPT_BOUNDARY bool PluginCrash(uint32_t aPluginID, + const nsAString& aPluginName); + + NS_IMETHODIMP_TO_ERRORRESULT(SetConfiguration, ErrorResult& rv, + const RTCConfiguration& aConfiguration) { + rv = SetConfiguration(aConfiguration); + } + + dom::RTCSctpTransport* GetSctp() const; + + void RestartIce(); + void RestartIceNoRenegotiationNeeded(); + + void RecordEndOfCallTelemetry(); + + nsresult InitializeDataChannel(); + + NS_IMETHODIMP_TO_ERRORRESULT_RETREF(nsDOMDataChannel, CreateDataChannel, + ErrorResult& rv, const nsAString& aLabel, + const nsAString& aProtocol, + uint16_t aType, bool outOfOrderAllowed, + uint16_t aMaxTime, uint16_t aMaxNum, + bool aExternalNegotiated, + uint16_t aStream); + + // Base class for chained operations. Necessary right now because some + // operations come from JS (in the form of dom::ChainedOperation), and others + // come from c++ (dom::ChainedOperation is very unwieldy and arcane to build + // in c++). Once we stop using JSImpl, we should be able to simplify this. + class Operation : public dom::PromiseNativeHandler { + public: + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + NS_DECL_CYCLE_COLLECTION_CLASS(Operation) + Operation(PeerConnectionImpl* aPc, ErrorResult& aError); + MOZ_CAN_RUN_SCRIPT + void Call(ErrorResult& aError); + dom::Promise* GetPromise() { return mPromise; } + MOZ_CAN_RUN_SCRIPT + void ResolvedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue, + ErrorResult& aRv) override; + + MOZ_CAN_RUN_SCRIPT + void RejectedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue, + ErrorResult& aRv) override; + + protected: + MOZ_CAN_RUN_SCRIPT + virtual RefPtr<dom::Promise> CallImpl(ErrorResult& aError) = 0; + virtual ~Operation(); + // This is the promise p from https://w3c.github.io/webrtc-pc/#dfn-chain + // This will be a content promise, since we return this to the caller of + // Chain. + RefPtr<dom::Promise> mPromise; + RefPtr<PeerConnectionImpl> mPc; + }; + + class JSOperation final : public Operation { + public: + JSOperation(PeerConnectionImpl* aPc, dom::ChainedOperation& aOp, + ErrorResult& aError); + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(JSOperation, Operation) + + private: + MOZ_CAN_RUN_SCRIPT + RefPtr<dom::Promise> CallImpl(ErrorResult& aError) override; + ~JSOperation() = default; + RefPtr<dom::ChainedOperation> mOperation; + }; + + MOZ_CAN_RUN_SCRIPT + already_AddRefed<dom::Promise> Chain(dom::ChainedOperation& aOperation, + ErrorResult& aError); + MOZ_CAN_RUN_SCRIPT + already_AddRefed<dom::Promise> Chain(const RefPtr<Operation>& aOperation, + ErrorResult& aError); + already_AddRefed<dom::Promise> MakePromise(ErrorResult& aError) const; + + void UpdateNegotiationNeeded(); + + void GetTransceivers( + nsTArray<RefPtr<dom::RTCRtpTransceiver>>& aTransceiversOut) { + aTransceiversOut = mTransceivers.Clone(); + } + + // Gets the RTC Signaling State of the JSEP session + dom::RTCSignalingState GetSignalingState() const; + + already_AddRefed<dom::Promise> OnSetDescriptionSuccess( + dom::RTCSdpType aSdpType, bool aRemote, ErrorResult& aError); + + void OnSetDescriptionError(); + + bool IsClosed() const; + + // called when DTLS connects; we only need this once + nsresult OnAlpnNegotiated(bool aPrivacyRequested); + + void OnDtlsStateChange(const std::string& aTransportId, + TransportLayer::State aState); + void UpdateConnectionState(); + dom::RTCPeerConnectionState GetNewConnectionState() const; + + // initialize telemetry for when calls start + void StartCallTelem(); + + // Gets all codec stats for all transports, coalesced to transport level. + nsTArray<dom::RTCCodecStats> GetCodecStats(DOMHighResTimeStamp aNow); + + RefPtr<dom::RTCStatsReportPromise> GetStats(dom::MediaStreamTrack* aSelector, + bool aInternalStats); + + void CollectConduitTelemetryData(); + + void OnMediaError(const std::string& aError); + + void DumpPacket_m(size_t level, dom::mozPacketDumpType type, bool sending, + UniquePtr<uint8_t[]>& packet, size_t size); + + const dom::RTCStatsTimestampMaker& GetTimestampMaker() const { + return mTimestampMaker; + } + + // Utility function, given a string pref and an URI, returns whether or not + // the URI occurs in the pref. Wildcards are supported (e.g. *.example.com) + // and multiple hostnames can be present, separated by commas. + static bool HostnameInPref(const char* aPrefList, const nsCString& aHostName); + + void StampTimecard(const char* aEvent); + + bool RelayOnly() const { + return mJsConfiguration.mIceTransportPolicy.WasPassed() && + mJsConfiguration.mIceTransportPolicy.Value() == + dom::RTCIceTransportPolicy::Relay; + } + + RefPtr<PacketDumper> GetPacketDumper() { + if (!mPacketDumper) { + mPacketDumper = new PacketDumper(mHandle); + } + + return mPacketDumper; + } + + nsString GenerateUUID() const { + std::string result; + if (!mUuidGen->Generate(&result)) { + MOZ_CRASH(); + } + return NS_ConvertUTF8toUTF16(result.c_str()); + } + + bool ShouldAllowOldSetParameters() const { return mAllowOldSetParameters; } + + nsCString GetHostname() const { return mHostname; } + nsCString GetEffectiveTLDPlus1() const { return mEffectiveTLDPlus1; } + + void SendWarningToConsole(const nsCString& aWarning); + + const UniquePtr<dom::RTCStatsReportInternal>& GetFinalStats() const { + return mFinalStats; + } + + void DisableLongTermStats() { mDisableLongTermStats = true; } + + bool LongTermStatsIsDisabled() const { return mDisableLongTermStats; } + + static void GetDefaultVideoCodecs( + std::vector<UniquePtr<JsepCodecDescription>>& aSupportedCodecs, + bool aUseRtx); + + static void GetDefaultAudioCodecs( + std::vector<UniquePtr<JsepCodecDescription>>& aSupportedCodecs); + + static void GetDefaultRtpExtensions( + std::vector<RtpExtensionHeader>& aRtpExtensions); + + static void GetCapabilities(const nsAString& aKind, + dom::Nullable<dom::RTCRtpCapabilities>& aResult, + sdp::Direction aDirection); + static void SetupPreferredCodecs( + std::vector<UniquePtr<JsepCodecDescription>>& aPreferredCodecs); + + static void SetupPreferredRtpExtensions( + std::vector<RtpExtensionHeader>& aPreferredheaders); + + private: + virtual ~PeerConnectionImpl(); + PeerConnectionImpl(const PeerConnectionImpl& rhs); + PeerConnectionImpl& operator=(PeerConnectionImpl); + + RefPtr<dom::RTCStatsPromise> GetDataChannelStats( + const RefPtr<DataChannelConnection>& aDataChannelConnection, + const DOMHighResTimeStamp aTimestamp); + nsresult CalculateFingerprint(const std::string& algorithm, + std::vector<uint8_t>* fingerprint) const; + nsresult ConfigureJsepSessionCodecs(); + + NS_IMETHODIMP EnsureDataConnection(uint16_t aLocalPort, uint16_t aNumstreams, + uint32_t aMaxMessageSize, bool aMMSSet); + + nsresult CheckApiState(bool assert_ice_ready) const; + void StoreFinalStats(UniquePtr<dom::RTCStatsReportInternal>&& report); + void CheckThread() const { MOZ_ASSERT(NS_IsMainThread(), "Wrong thread"); } + + // test-only: called from AddRIDExtension and AddRIDFilter + // for simulcast mochitests. + RefPtr<MediaPipeline> GetMediaPipelineForTrack( + dom::MediaStreamTrack& aRecvTrack); + + void CandidateReady(const std::string& candidate, + const std::string& transportId, const std::string& ufrag); + void SendLocalIceCandidateToContent(uint16_t level, const std::string& mid, + const std::string& candidate, + const std::string& ufrag); + + nsresult GetDatachannelParameters(uint32_t* channels, uint16_t* localport, + uint16_t* remoteport, + uint32_t* maxmessagesize, bool* mmsset, + std::string* transportId, + bool* client) const; + + nsresult AddRtpTransceiverToJsepSession(JsepTransceiver& transceiver); + + void RecordIceRestartStatistics(JsepSdpType type); + + void StoreConfigurationForAboutWebrtc(const RTCConfiguration& aConfig); + + dom::Sequence<dom::RTCSdpParsingErrorInternal> GetLastSdpParsingErrors() + const; + + MOZ_CAN_RUN_SCRIPT + void RunNextOperation(ErrorResult& aError); + + void SyncToJsep(); + void SyncFromJsep(); + + void DoSetDescriptionSuccessPostProcessing(dom::RTCSdpType aSdpType, + bool aRemote, + const RefPtr<dom::Promise>& aP); + + // Timecard used to measure processing time. This should be the first class + // attribute so that we accurately measure the time required to instantiate + // any other attributes of this class. + Timecard* mTimeCard; + + // Configuration used to initialize the PeerConnection + dom::RTCConfigurationInternal mJsConfiguration; + + mozilla::dom::RTCSignalingState mSignalingState; + + // ICE State + mozilla::dom::RTCIceConnectionState mIceConnectionState; + mozilla::dom::RTCIceGatheringState mIceGatheringState; + + mozilla::dom::RTCPeerConnectionState mConnectionState; + + RefPtr<PeerConnectionObserver> mPCObserver; + + nsCOMPtr<nsPIDOMWindowInner> mWindow; + + // The SDP sent in from JS + std::string mLocalRequestedSDP; + std::string mRemoteRequestedSDP; + // Only accessed from main + mozilla::dom::Sequence<mozilla::dom::RTCSdpHistoryEntryInternal> mSdpHistory; + std::string mPendingLocalDescription; + std::string mPendingRemoteDescription; + std::string mCurrentLocalDescription; + std::string mCurrentRemoteDescription; + Maybe<bool> mPendingOfferer; + Maybe<bool> mCurrentOfferer; + + // DTLS fingerprint + std::string mFingerprint; + std::string mRemoteFingerprint; + + // identity-related fields + // The entity on the other end of the peer-to-peer connection; + // void if they are not yet identified, and no identity setting has been set + RefPtr<PeerIdentity> mPeerIdentity; + // The certificate we are using. + RefPtr<mozilla::dom::RTCCertificate> mCertificate; + // Whether an app should be prevented from accessing media produced by the PC + // If this is true, then media will not be sent until mPeerIdentity matches + // local streams PeerIdentity; and remote streams are protected from content + // + // This can be false if mPeerIdentity is set, in the case where identity is + // provided, but the media is not protected from the app on either side + Maybe<PrincipalPrivacy> mRequestedPrivacy; + + // A handle to refer to this PC with + std::string mHandle; + + // A name for this PC that we are willing to expose to content. + std::string mName; + nsCString mHostname; + nsCString mEffectiveTLDPlus1; + + // The target to run stuff on + nsCOMPtr<nsISerialEventTarget> mSTSThread; + + // DataConnection that's used to get all the DataChannels + RefPtr<mozilla::DataChannelConnection> mDataConnection; + unsigned int mDataChannelsOpened = 0; + unsigned int mDataChannelsClosed = 0; + + bool mForceIceTcp; + RefPtr<MediaTransportHandler> mTransportHandler; + + // The JSEP negotiation session. + mozilla::UniquePtr<PCUuidGenerator> mUuidGen; + mozilla::UniquePtr<mozilla::JsepSession> mJsepSession; + // There are lots of error cases where we want to abandon an sRD/sLD _after_ + // it has already been applied to the JSEP engine, and revert back to the + // previous state. We also want to ensure that the various modifications + // to the JSEP engine are not exposed to JS until the sRD/sLD completes, + // which is why we have a new "uncommitted" JSEP engine. + mozilla::UniquePtr<mozilla::JsepSession> mUncommittedJsepSession; + unsigned long mIceRestartCount; + unsigned long mIceRollbackCount; + + // The following are used for Telemetry: + bool mCallTelemStarted = false; + bool mCallTelemEnded = false; + + // We _could_ make mFinalStatsQuery be an RTCStatsReportPromise, but that + // would require RTCStatsReportPromise to no longer be exclusive, which is + // a bit of a hassle, and not very performant. + RefPtr<GenericNonExclusivePromise> mFinalStatsQuery; + UniquePtr<dom::RTCStatsReportInternal> mFinalStats; + bool mDisableLongTermStats = false; + + // Start time of ICE. + mozilla::TimeStamp mIceStartTime; + // Hold PeerConnectionAutoTimer instances for each window. + static std::map<uint64_t, PeerConnectionAutoTimer> sCallDurationTimers; + + bool mHaveConfiguredCodecs; + + bool mTrickle; + + bool mPrivateWindow; + + // Whether this PeerConnection is being counted as active by mWindow + bool mActiveOnWindow; + + // storage for Telemetry data + uint16_t mMaxReceiving[SdpMediaSection::kMediaTypes]; + uint16_t mMaxSending[SdpMediaSection::kMediaTypes]; + + // used to store the raw trickle candidate string for display + // on the about:webrtc raw candidates table. + std::vector<std::string> mRawTrickledCandidates; + + dom::RTCStatsTimestampMaker mTimestampMaker; + + RefPtr<RTCStatsIdGenerator> mIdGenerator; + // Ordinarily, I would use a std::map here, but this used to be a JS Map + // which iterates in insertion order, and I want to avoid changing this. + nsTArray<RefPtr<DOMMediaStream>> mReceiveStreams; + + DOMMediaStream* GetReceiveStream(const std::string& aId) const; + DOMMediaStream* CreateReceiveStream(const std::string& aId); + + void InitLocalAddrs(); // for stun local address IPC request + bool ShouldForceProxy() const; + std::unique_ptr<NrSocketProxyConfig> GetProxyConfig() const; + + class StunAddrsHandler : public net::StunAddrsListener { + public: + explicit StunAddrsHandler(PeerConnectionImpl* aPc) + : mPcHandle(aPc->GetHandle()) {} + + void OnMDNSQueryComplete(const nsCString& hostname, + const Maybe<nsCString>& address) override; + + void OnStunAddrsAvailable( + const mozilla::net::NrIceStunAddrArray& addrs) override; + + private: + // This class is not cycle-collected, so we must avoid grabbing a strong + // reference. + const std::string mPcHandle; + virtual ~StunAddrsHandler() {} + }; + + // Manage ICE transports. + void UpdateTransport(const JsepTransceiver& aTransceiver, bool aForceIceTcp); + + void GatherIfReady(); + void FlushIceCtxOperationQueueIfReady(); + void PerformOrEnqueueIceCtxOperation(nsIRunnable* runnable); + nsresult SetTargetForDefaultLocalAddressLookup(); + void EnsureIceGathering(bool aDefaultRouteOnly, bool aObfuscateHostAddresses); + + bool GetPrefDefaultAddressOnly() const; + bool GetPrefObfuscateHostAddresses() const; + + bool IsIceCtxReady() const { + return mLocalAddrsRequestState == STUN_ADDR_REQUEST_COMPLETE; + } + + // Ensure ICE transports exist that we might need when offer/answer concludes + void EnsureTransports(const JsepSession& aSession); + + void UpdateRTCDtlsTransports(bool aMarkAsStable); + void RollbackRTCDtlsTransports(); + void RemoveRTCDtlsTransportsExcept( + const std::set<std::string>& aTransportIds); + + // Activate ICE transports at the conclusion of offer/answer, + // or when rollback occurs. + nsresult UpdateTransports(const JsepSession& aSession, + const bool forceIceTcp); + + void ResetStunAddrsForIceRestart() { mStunAddrs.Clear(); } + + // Start ICE checks. + void StartIceChecks(const JsepSession& session); + + // Process a trickle ICE candidate. + void AddIceCandidate(const std::string& candidate, + const std::string& aTransportId, + const std::string& aUFrag); + + // Handle complete media pipelines. + // This updates codec parameters, starts/stops send/receive, and other + // stuff that doesn't necessarily require negotiation. This can be called at + // any time, not just when an offer/answer exchange completes. + nsresult UpdateMediaPipelines(); + + already_AddRefed<dom::RTCRtpTransceiver> CreateTransceiver( + const std::string& aId, bool aIsVideo, + const dom::RTCRtpTransceiverInit& aInit, + dom::MediaStreamTrack* aSendTrack, bool aAddTrackMagic, ErrorResult& aRv); + + std::string GetTransportIdMatchingSendTrack( + const dom::MediaStreamTrack& aTrack) const; + + // this determines if any track is peerIdentity constrained + bool AnyLocalTrackHasPeerIdentity() const; + + bool AnyCodecHasPluginID(uint64_t aPluginID); + + already_AddRefed<nsIHttpChannelInternal> GetChannel() const; + + void BreakCycles(); + + bool HasPendingSetParameters() const; + void InvalidateLastReturnedParameters(); + + RefPtr<WebrtcCallWrapper> mCall; + + // See Bug 1642419, this can be removed when all sites are working with RTX. + bool mRtxIsAllowed = true; + + nsTArray<RefPtr<Operation>> mOperations; + bool mChainingOperation = false; + bool mUpdateNegotiationNeededFlagOnEmptyChain = false; + bool mNegotiationNeeded = false; + std::set<std::pair<std::string, std::string>> mLocalIceCredentialsToReplace; + + nsTArray<RefPtr<dom::RTCRtpTransceiver>> mTransceivers; + std::map<std::string, RefPtr<dom::RTCDtlsTransport>> + mTransportIdToRTCDtlsTransport; + RefPtr<dom::RTCSctpTransport> mSctpTransport; + + // Used whenever we need to dispatch a runnable to STS to tweak something + // on our ICE ctx, but are not ready to do so at the moment (eg; we are + // waiting to get a callback with our http proxy config before we start + // gathering or start checking) + std::vector<nsCOMPtr<nsIRunnable>> mQueuedIceCtxOperations; + + // Set if prefs dictate that we should force the use of a web proxy. + bool mForceProxy = false; + + // Used to cancel incoming stun addrs response + RefPtr<net::StunAddrsRequestChild> mStunAddrsRequest; + + enum StunAddrRequestState { + STUN_ADDR_REQUEST_NONE, + STUN_ADDR_REQUEST_PENDING, + STUN_ADDR_REQUEST_COMPLETE + }; + // Used to track the state of the stun addr IPC request + StunAddrRequestState mLocalAddrsRequestState = STUN_ADDR_REQUEST_NONE; + + // Used to store the result of the stun addr IPC request + nsTArray<NrIceStunAddr> mStunAddrs; + + // Used to ensure the target for default local address lookup is only set + // once. + bool mTargetForDefaultLocalAddressLookupIsSet = false; + + // Keep track of local hostnames to register. Registration is deferred + // until StartIceChecks has run. Accessed on main thread only. + std::map<std::string, std::string> mMDNSHostnamesToRegister; + bool mCanRegisterMDNSHostnamesDirectly = false; + + // Used to store the mDNS hostnames that we have registered + std::set<std::string> mRegisteredMDNSHostnames; + + // web-compat stopgap + bool mAllowOldSetParameters = false; + + // Used to store the mDNS hostnames that we have queried + struct PendingIceCandidate { + std::vector<std::string> mTokenizedCandidate; + std::string mTransportId; + std::string mUfrag; + }; + std::map<std::string, std::list<PendingIceCandidate>> mQueriedMDNSHostnames; + + // Connecting PCImpl to sigslot is not safe, because sigslot takes strong + // references without any reference counting, and JS holds refcounted strong + // references to PCImpl (meaning JS can cause PCImpl to be destroyed). This + // is not ref-counted (since sigslot holds onto non-refcounted strong refs) + // Must be destroyed on STS. Holds a weak reference to PCImpl. + class SignalHandler : public sigslot::has_slots<> { + public: + SignalHandler(PeerConnectionImpl* aPc, MediaTransportHandler* aSource); + virtual ~SignalHandler(); + + void ConnectSignals(); + + // ICE events + void IceGatheringStateChange_s(dom::RTCIceGatheringState aState); + void IceConnectionStateChange_s(dom::RTCIceConnectionState aState); + void OnCandidateFound_s(const std::string& aTransportId, + const CandidateInfo& aCandidateInfo); + void AlpnNegotiated_s(const std::string& aAlpn, bool aPrivacyRequested); + void ConnectionStateChange_s(const std::string& aTransportId, + TransportLayer::State aState); + + private: + const std::string mHandle; + RefPtr<MediaTransportHandler> mSource; + RefPtr<nsISerialEventTarget> mSTSThread; + }; + + mozilla::UniquePtr<SignalHandler> mSignalHandler; + + // Make absolutely sure our refcount does not go to 0 before Close() is called + // This is because Close does a stats query, which needs the + // PeerConnectionImpl to stick around until the query is done. + RefPtr<PeerConnectionImpl> mKungFuDeathGrip; + RefPtr<PacketDumper> mPacketDumper; + + public: + // these are temporary until the DataChannel Listen/Connect API is removed + unsigned short listenPort; + unsigned short connectPort; + char* connectStr; // XXX ownership/free +}; + +// This is what is returned when you acquire on a handle +class PeerConnectionWrapper { + public: + explicit PeerConnectionWrapper(const std::string& handle); + + PeerConnectionImpl* impl() { return impl_; } + + private: + RefPtr<PeerConnectionImpl> impl_; +}; + +} // namespace mozilla + +#undef NS_IMETHODIMP_TO_ERRORRESULT +#undef NS_IMETHODIMP_TO_ERRORRESULT_RETREF +#endif // _PEER_CONNECTION_IMPL_H_ diff --git a/dom/media/webrtc/jsapi/RTCDTMFSender.cpp b/dom/media/webrtc/jsapi/RTCDTMFSender.cpp new file mode 100644 index 0000000000..30355aca26 --- /dev/null +++ b/dom/media/webrtc/jsapi/RTCDTMFSender.cpp @@ -0,0 +1,159 @@ +/* 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 "RTCDTMFSender.h" +#include "libwebrtcglue/MediaConduitInterface.h" +#include "transport/logging.h" +#include "RTCRtpTransceiver.h" +#include "nsITimer.h" +#include "mozilla/dom/RTCDTMFSenderBinding.h" +#include "mozilla/dom/RTCDTMFToneChangeEvent.h" +#include <algorithm> +#include <bitset> + +namespace mozilla::dom { + +NS_IMPL_CYCLE_COLLECTION_INHERITED(RTCDTMFSender, DOMEventTargetHelper, + mTransceiver, mSendTimer) + +NS_IMPL_ADDREF_INHERITED(RTCDTMFSender, DOMEventTargetHelper) +NS_IMPL_RELEASE_INHERITED(RTCDTMFSender, DOMEventTargetHelper) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(RTCDTMFSender) + NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY + NS_INTERFACE_MAP_ENTRY(nsITimerCallback) + NS_INTERFACE_MAP_ENTRY(nsINamed) +NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper) + +LazyLogModule gDtmfLog("RTCDTMFSender"); + +RTCDTMFSender::RTCDTMFSender(nsPIDOMWindowInner* aWindow, + RTCRtpTransceiver* aTransceiver) + : DOMEventTargetHelper(aWindow), mTransceiver(aTransceiver) {} + +JSObject* RTCDTMFSender::WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) { + return RTCDTMFSender_Binding::Wrap(aCx, this, aGivenProto); +} + +static int GetDTMFToneCode(uint16_t c) { + const char* DTMF_TONECODES = "0123456789*#ABCD"; + + if (c == ',') { + // , is a special character indicating a 2 second delay + return -1; + } + + const char* i = strchr(DTMF_TONECODES, c); + MOZ_ASSERT(i); + return static_cast<int>(i - DTMF_TONECODES); +} + +static std::bitset<256> GetCharacterBitset(const std::string& aCharsInSet) { + std::bitset<256> result; + for (auto c : aCharsInSet) { + result[c] = true; + } + return result; +} + +static bool IsUnrecognizedChar(const char c) { + static const std::bitset<256> recognized = + GetCharacterBitset("0123456789ABCD#*,"); + return !recognized[c]; +} + +void RTCDTMFSender::SetPayloadType(int32_t aPayloadType, + int32_t aPayloadFrequency) { + MOZ_ASSERT(NS_IsMainThread()); + mPayloadType = Some(aPayloadType); + mPayloadFrequency = Some(aPayloadFrequency); +} + +void RTCDTMFSender::InsertDTMF(const nsAString& aTones, uint32_t aDuration, + uint32_t aInterToneGap, ErrorResult& aRv) { + if (!mTransceiver->CanSendDTMF()) { + aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR); + return; + } + + std::string utf8Tones = NS_ConvertUTF16toUTF8(aTones).get(); + + std::transform(utf8Tones.begin(), utf8Tones.end(), utf8Tones.begin(), + [](const char c) { return std::toupper(c); }); + + if (std::any_of(utf8Tones.begin(), utf8Tones.end(), IsUnrecognizedChar)) { + aRv.Throw(NS_ERROR_DOM_INVALID_CHARACTER_ERR); + return; + } + + CopyUTF8toUTF16(utf8Tones, mToneBuffer); + mDuration = std::clamp(aDuration, 40U, 6000U); + mInterToneGap = std::clamp(aInterToneGap, 30U, 6000U); + + if (mToneBuffer.Length()) { + StartPlayout(0); + } +} + +void RTCDTMFSender::StopPlayout() { + if (mSendTimer) { + mSendTimer->Cancel(); + mSendTimer = nullptr; + } +} + +void RTCDTMFSender::StartPlayout(uint32_t aDelay) { + if (!mSendTimer) { + mSendTimer = NS_NewTimer(); + mSendTimer->InitWithCallback(this, aDelay, nsITimer::TYPE_ONE_SHOT); + } +} + +nsresult RTCDTMFSender::Notify(nsITimer* timer) { + MOZ_ASSERT(NS_IsMainThread()); + StopPlayout(); + + if (!mTransceiver->IsSending()) { + return NS_OK; + } + + RTCDTMFToneChangeEventInit init; + if (!mToneBuffer.IsEmpty()) { + uint16_t toneChar = mToneBuffer.CharAt(0); + int tone = GetDTMFToneCode(toneChar); + + init.mTone.Assign(toneChar); + + mToneBuffer.Cut(0, 1); + + if (tone == -1) { + StartPlayout(2000); + } else { + // Reset delay if necessary + StartPlayout(mDuration + mInterToneGap); + mDtmfEvent.Notify(DtmfEvent(mPayloadType.ref(), mPayloadFrequency.ref(), + tone, mDuration)); + } + } + + RefPtr<RTCDTMFToneChangeEvent> event = + RTCDTMFToneChangeEvent::Constructor(this, u"tonechange"_ns, init); + DispatchTrustedEvent(event); + + return NS_OK; +} + +nsresult RTCDTMFSender::GetName(nsACString& aName) { + aName.AssignLiteral("RTCDTMFSender"); + return NS_OK; +} + +void RTCDTMFSender::GetToneBuffer(nsAString& aOutToneBuffer) { + aOutToneBuffer = mToneBuffer; +} + +} // namespace mozilla::dom + +#undef LOGTAG diff --git a/dom/media/webrtc/jsapi/RTCDTMFSender.h b/dom/media/webrtc/jsapi/RTCDTMFSender.h new file mode 100644 index 0000000000..14be7eb6ee --- /dev/null +++ b/dom/media/webrtc/jsapi/RTCDTMFSender.h @@ -0,0 +1,78 @@ +/* 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/. */ + +#ifndef _RTCDTMFSender_h_ +#define _RTCDTMFSender_h_ + +#include "MediaEventSource.h" +#include "mozilla/DOMEventTargetHelper.h" +#include "mozilla/RefPtr.h" +#include "js/RootingAPI.h" +#include "nsITimer.h" + +class nsPIDOMWindowInner; +class nsITimer; + +namespace mozilla { +class AudioSessionConduit; + +struct DtmfEvent { + DtmfEvent(int aPayloadType, int aPayloadFrequency, int aEventCode, + int aLengthMs) + : mPayloadType(aPayloadType), + mPayloadFrequency(aPayloadFrequency), + mEventCode(aEventCode), + mLengthMs(aLengthMs) {} + const int mPayloadType; + const int mPayloadFrequency; + const int mEventCode; + const int mLengthMs; +}; + +namespace dom { +class RTCRtpTransceiver; + +class RTCDTMFSender : public DOMEventTargetHelper, + public nsITimerCallback, + public nsINamed { + public: + RTCDTMFSender(nsPIDOMWindowInner* aWindow, RTCRtpTransceiver* aTransceiver); + + // nsISupports + NS_DECL_NSITIMERCALLBACK + NS_DECL_NSINAMED + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(RTCDTMFSender, DOMEventTargetHelper) + + // webidl + JSObject* WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) override; + void SetPayloadType(int32_t aPayloadType, int32_t aPayloadFrequency); + void InsertDTMF(const nsAString& aTones, uint32_t aDuration, + uint32_t aInterToneGap, ErrorResult& aRv); + void GetToneBuffer(nsAString& aOutToneBuffer); + IMPL_EVENT_HANDLER(tonechange) + + void StopPlayout(); + + MediaEventSource<DtmfEvent>& OnDtmfEvent() { return mDtmfEvent; } + + private: + virtual ~RTCDTMFSender() = default; + + void StartPlayout(uint32_t aDelay); + + RefPtr<RTCRtpTransceiver> mTransceiver; + MediaEventProducer<DtmfEvent> mDtmfEvent; + Maybe<int32_t> mPayloadType; + Maybe<int32_t> mPayloadFrequency; + nsString mToneBuffer; + uint32_t mDuration = 0; + uint32_t mInterToneGap = 0; + nsCOMPtr<nsITimer> mSendTimer; +}; + +} // namespace dom +} // namespace mozilla +#endif // _RTCDTMFSender_h_ diff --git a/dom/media/webrtc/jsapi/RTCDtlsTransport.cpp b/dom/media/webrtc/jsapi/RTCDtlsTransport.cpp new file mode 100644 index 0000000000..442e9c7a17 --- /dev/null +++ b/dom/media/webrtc/jsapi/RTCDtlsTransport.cpp @@ -0,0 +1,69 @@ +/* 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 "RTCDtlsTransport.h" +#include "mozilla/dom/Event.h" +#include "mozilla/dom/EventBinding.h" +#include "mozilla/dom/RTCDtlsTransportBinding.h" + +namespace mozilla::dom { + +NS_IMPL_CYCLE_COLLECTION_INHERITED(RTCDtlsTransport, DOMEventTargetHelper) + +NS_IMPL_ADDREF_INHERITED(RTCDtlsTransport, DOMEventTargetHelper) +NS_IMPL_RELEASE_INHERITED(RTCDtlsTransport, DOMEventTargetHelper) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(RTCDtlsTransport) + NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY +NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper) + +RTCDtlsTransport::RTCDtlsTransport(nsPIDOMWindowInner* aWindow) + : DOMEventTargetHelper(aWindow), mState(RTCDtlsTransportState::New) {} + +JSObject* RTCDtlsTransport::WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) { + return RTCDtlsTransport_Binding::Wrap(aCx, this, aGivenProto); +} + +void RTCDtlsTransport::UpdateState(TransportLayer::State aState) { + if (mState == RTCDtlsTransportState::Closed) { + return; + } + + RTCDtlsTransportState newState = mState; + switch (aState) { + case TransportLayer::TS_NONE: + break; + case TransportLayer::TS_INIT: + break; + case TransportLayer::TS_CONNECTING: + newState = RTCDtlsTransportState::Connecting; + break; + case TransportLayer::TS_OPEN: + newState = RTCDtlsTransportState::Connected; + break; + case TransportLayer::TS_CLOSED: + newState = RTCDtlsTransportState::Closed; + break; + case TransportLayer::TS_ERROR: + newState = RTCDtlsTransportState::Failed; + break; + } + + if (newState == mState) { + return; + } + + mState = newState; + + EventInit init; + init.mBubbles = false; + init.mCancelable = false; + + RefPtr<Event> event = Event::Constructor(this, u"statechange"_ns, init); + + DispatchTrustedEvent(event); +} + +} // namespace mozilla::dom diff --git a/dom/media/webrtc/jsapi/RTCDtlsTransport.h b/dom/media/webrtc/jsapi/RTCDtlsTransport.h new file mode 100644 index 0000000000..74a4b5f618 --- /dev/null +++ b/dom/media/webrtc/jsapi/RTCDtlsTransport.h @@ -0,0 +1,43 @@ +/* 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/. */ + +#ifndef _RTCDtlsTransport_h_ +#define _RTCDtlsTransport_h_ + +#include "mozilla/DOMEventTargetHelper.h" +#include "mozilla/RefPtr.h" +#include "js/RootingAPI.h" +#include "transport/transportlayer.h" + +class nsPIDOMWindowInner; + +namespace mozilla::dom { + +enum class RTCDtlsTransportState : uint8_t; + +class RTCDtlsTransport : public DOMEventTargetHelper { + public: + explicit RTCDtlsTransport(nsPIDOMWindowInner* aWindow); + + // nsISupports + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(RTCDtlsTransport, + DOMEventTargetHelper) + + // webidl + JSObject* WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) override; + IMPL_EVENT_HANDLER(statechange) + RTCDtlsTransportState State() const { return mState; } + + void UpdateState(TransportLayer::State aState); + + private: + virtual ~RTCDtlsTransport() = default; + + RTCDtlsTransportState mState; +}; + +} // namespace mozilla::dom +#endif // _RTCDtlsTransport_h_ diff --git a/dom/media/webrtc/jsapi/RTCRtpReceiver.cpp b/dom/media/webrtc/jsapi/RTCRtpReceiver.cpp new file mode 100644 index 0000000000..136aa5142f --- /dev/null +++ b/dom/media/webrtc/jsapi/RTCRtpReceiver.cpp @@ -0,0 +1,942 @@ +/* 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 "RTCRtpReceiver.h" +#include "PeerConnectionImpl.h" +#include "mozilla/dom/RTCRtpCapabilitiesBinding.h" +#include "transport/logging.h" +#include "mozilla/dom/MediaStreamTrack.h" +#include "mozilla/dom/Promise.h" +#include "nsPIDOMWindow.h" +#include "PrincipalHandle.h" +#include "nsIPrincipal.h" +#include "mozilla/dom/Document.h" +#include "mozilla/NullPrincipal.h" +#include "MediaTrackGraph.h" +#include "RemoteTrackSource.h" +#include "libwebrtcglue/RtpRtcpConfig.h" +#include "nsString.h" +#include "mozilla/dom/AudioStreamTrack.h" +#include "mozilla/dom/VideoStreamTrack.h" +#include "MediaTransportHandler.h" +#include "jsep/JsepTransceiver.h" +#include "mozilla/dom/RTCRtpReceiverBinding.h" +#include "mozilla/dom/RTCRtpSourcesBinding.h" +#include "RTCStatsReport.h" +#include "mozilla/Preferences.h" +#include "PeerConnectionCtx.h" +#include "RTCRtpTransceiver.h" +#include "libwebrtcglue/AudioConduit.h" +#include "call/call.h" + +namespace mozilla::dom { + +LazyLogModule gReceiverLog("RTCRtpReceiver"); + +NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(RTCRtpReceiver) +NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(RTCRtpReceiver) + // We do not do anything here, we wait for BreakCycles to be called + NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER +NS_IMPL_CYCLE_COLLECTION_UNLINK_END +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(RTCRtpReceiver) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mWindow, mPc, mTransceiver, mTrack, + mTrackSource) +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END + +NS_IMPL_CYCLE_COLLECTING_ADDREF(RTCRtpReceiver) +NS_IMPL_CYCLE_COLLECTING_RELEASE(RTCRtpReceiver) +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(RTCRtpReceiver) + NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY + NS_INTERFACE_MAP_ENTRY(nsISupports) +NS_INTERFACE_MAP_END + +static PrincipalHandle GetPrincipalHandle(nsPIDOMWindowInner* aWindow, + PrincipalPrivacy aPrivacy) { + // Set the principal used for creating the tracks. This makes the track + // data (audio/video samples) accessible to the receiving page. We're + // only certain that privacy hasn't been requested if we're connected. + nsCOMPtr<nsIScriptObjectPrincipal> winPrincipal = do_QueryInterface(aWindow); + RefPtr<nsIPrincipal> principal = winPrincipal->GetPrincipal(); + if (NS_WARN_IF(!principal)) { + principal = NullPrincipal::CreateWithoutOriginAttributes(); + } else if (aPrivacy == PrincipalPrivacy::Private) { + principal = NullPrincipal::CreateWithInheritedAttributes(principal); + } + return MakePrincipalHandle(principal); +} + +#define INIT_CANONICAL(name, val) \ + name(AbstractThread::MainThread(), val, \ + "RTCRtpReceiver::" #name " (Canonical)") + +RTCRtpReceiver::RTCRtpReceiver( + nsPIDOMWindowInner* aWindow, PrincipalPrivacy aPrivacy, + PeerConnectionImpl* aPc, MediaTransportHandler* aTransportHandler, + AbstractThread* aCallThread, nsISerialEventTarget* aStsThread, + MediaSessionConduit* aConduit, RTCRtpTransceiver* aTransceiver, + const TrackingId& aTrackingId) + : mWatchManager(this, AbstractThread::MainThread()), + mWindow(aWindow), + mPc(aPc), + mCallThread(aCallThread), + mStsThread(aStsThread), + mTransportHandler(aTransportHandler), + mTransceiver(aTransceiver), + INIT_CANONICAL(mSsrc, 0), + INIT_CANONICAL(mVideoRtxSsrc, 0), + INIT_CANONICAL(mLocalRtpExtensions, RtpExtList()), + INIT_CANONICAL(mAudioCodecs, std::vector<AudioCodecConfig>()), + INIT_CANONICAL(mVideoCodecs, std::vector<VideoCodecConfig>()), + INIT_CANONICAL(mVideoRtpRtcpConfig, Nothing()), + INIT_CANONICAL(mReceiving, false) { + PrincipalHandle principalHandle = GetPrincipalHandle(aWindow, aPrivacy); + const bool isAudio = aConduit->type() == MediaSessionConduit::AUDIO; + + MediaTrackGraph* graph = MediaTrackGraph::GetInstance( + isAudio ? MediaTrackGraph::AUDIO_THREAD_DRIVER + : MediaTrackGraph::SYSTEM_THREAD_DRIVER, + aWindow, MediaTrackGraph::REQUEST_DEFAULT_SAMPLE_RATE, + MediaTrackGraph::DEFAULT_OUTPUT_DEVICE); + + if (isAudio) { + auto* source = graph->CreateSourceTrack(MediaSegment::AUDIO); + mTrackSource = MakeAndAddRef<RemoteTrackSource>( + source, this, principalHandle, u"remote audio"_ns, aTrackingId); + mTrack = MakeAndAddRef<AudioStreamTrack>(aWindow, source, mTrackSource); + mPipeline = MakeAndAddRef<MediaPipelineReceiveAudio>( + mPc->GetHandle(), aTransportHandler, aCallThread, mStsThread.get(), + *aConduit->AsAudioSessionConduit(), mTrackSource->Stream(), aTrackingId, + principalHandle, aPrivacy); + } else { + auto* source = graph->CreateSourceTrack(MediaSegment::VIDEO); + mTrackSource = MakeAndAddRef<RemoteTrackSource>( + source, this, principalHandle, u"remote video"_ns, aTrackingId); + mTrack = MakeAndAddRef<VideoStreamTrack>(aWindow, source, mTrackSource); + mPipeline = MakeAndAddRef<MediaPipelineReceiveVideo>( + mPc->GetHandle(), aTransportHandler, aCallThread, mStsThread.get(), + *aConduit->AsVideoSessionConduit(), mTrackSource->Stream(), aTrackingId, + principalHandle, aPrivacy); + } + + mPipeline->InitControl(this); + + // Spec says remote tracks start out muted. + mTrackSource->SetMuted(true); + + // Until Bug 1232234 is fixed, we'll get extra RTCP BYES during renegotiation, + // so we'll disable muting on RTCP BYE and timeout for now. + if (Preferences::GetBool("media.peerconnection.mute_on_bye_or_timeout", + false)) { + mRtcpByeListener = aConduit->RtcpByeEvent().Connect( + GetMainThreadSerialEventTarget(), this, &RTCRtpReceiver::OnRtcpBye); + mRtcpTimeoutListener = aConduit->RtcpTimeoutEvent().Connect( + GetMainThreadSerialEventTarget(), this, &RTCRtpReceiver::OnRtcpTimeout); + } + + mWatchManager.Watch(mReceiveTrackMute, + &RTCRtpReceiver::UpdateReceiveTrackMute); +} + +#undef INIT_CANONICAL + +RTCRtpReceiver::~RTCRtpReceiver() { MOZ_ASSERT(!mPipeline); } + +JSObject* RTCRtpReceiver::WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) { + return RTCRtpReceiver_Binding::Wrap(aCx, this, aGivenProto); +} + +RTCDtlsTransport* RTCRtpReceiver::GetTransport() const { + if (!mTransceiver) { + return nullptr; + } + return mTransceiver->GetDtlsTransport(); +} + +void RTCRtpReceiver::GetCapabilities( + const GlobalObject&, const nsAString& aKind, + Nullable<dom::RTCRtpCapabilities>& aResult) { + PeerConnectionImpl::GetCapabilities(aKind, aResult, sdp::Direction::kRecv); +} + +already_AddRefed<Promise> RTCRtpReceiver::GetStats(ErrorResult& aError) { + nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(mWindow); + RefPtr<Promise> promise = Promise::Create(global, aError); + if (NS_WARN_IF(aError.Failed())) { + return nullptr; + } + + if (NS_WARN_IF(!mTransceiver)) { + // TODO(bug 1056433): When we stop nulling this out when the PC is closed + // (or when the transceiver is stopped), we can remove this code. We + // resolve instead of reject in order to make this eventual change in + // behavior a little smaller. + promise->MaybeResolve(new RTCStatsReport(mWindow)); + return promise.forget(); + } + + mTransceiver->ChainToDomPromiseWithCodecStats(GetStatsInternal(), promise); + return promise.forget(); +} + +nsTArray<RefPtr<RTCStatsPromise>> RTCRtpReceiver::GetStatsInternal( + bool aSkipIceStats) { + MOZ_ASSERT(NS_IsMainThread()); + nsTArray<RefPtr<RTCStatsPromise>> promises(3); + + if (!mPipeline) { + return promises; + } + + if (!mHaveStartedReceiving) { + return promises; + } + + nsString recvTrackId; + MOZ_ASSERT(mTrack); + if (mTrack) { + mTrack->GetId(recvTrackId); + } + + { + // Add bandwidth estimation stats + promises.AppendElement(InvokeAsync( + mCallThread, __func__, + [conduit = mPipeline->mConduit, recvTrackId]() mutable { + auto report = MakeUnique<dom::RTCStatsCollection>(); + const Maybe<webrtc::Call::Stats> stats = conduit->GetCallStats(); + stats.apply([&](const auto& aStats) { + dom::RTCBandwidthEstimationInternal bw; + bw.mTrackIdentifier = recvTrackId; + bw.mSendBandwidthBps.Construct(aStats.send_bandwidth_bps / 8); + bw.mMaxPaddingBps.Construct(aStats.max_padding_bitrate_bps / 8); + bw.mReceiveBandwidthBps.Construct(aStats.recv_bandwidth_bps / 8); + bw.mPacerDelayMs.Construct(aStats.pacer_delay_ms); + if (aStats.rtt_ms >= 0) { + bw.mRttMs.Construct(aStats.rtt_ms); + } + if (!report->mBandwidthEstimations.AppendElement(std::move(bw), + fallible)) { + mozalloc_handle_oom(0); + } + }); + return RTCStatsPromise::CreateAndResolve(std::move(report), __func__); + })); + } + + promises.AppendElement( + InvokeAsync( + mCallThread, __func__, + [pipeline = mPipeline, recvTrackId] { + auto report = MakeUnique<dom::RTCStatsCollection>(); + auto asAudio = pipeline->mConduit->AsAudioSessionConduit(); + auto asVideo = pipeline->mConduit->AsVideoSessionConduit(); + + nsString kind = asVideo.isNothing() ? u"audio"_ns : u"video"_ns; + nsString idstr = kind + u"_"_ns; + idstr.AppendInt(static_cast<uint32_t>(pipeline->Level())); + + Maybe<uint32_t> ssrc = pipeline->mConduit->GetRemoteSSRC(); + + // Add frame history + asVideo.apply([&](const auto& conduit) { + if (conduit->AddFrameHistory(&report->mVideoFrameHistories)) { + auto& history = report->mVideoFrameHistories.LastElement(); + history.mTrackIdentifier = recvTrackId; + } + }); + + // TODO(@@NG):ssrcs handle Conduits having multiple stats at the + // same level. + // This is pending spec work. + // Gather pipeline stats. + nsString localId = u"inbound_rtp_"_ns + idstr; + nsString remoteId; + + auto constructCommonRemoteOutboundRtpStats = + [&](RTCRemoteOutboundRtpStreamStats& aRemote, + const DOMHighResTimeStamp& aTimestamp) { + remoteId = u"inbound_rtcp_"_ns + idstr; + aRemote.mTimestamp.Construct(aTimestamp); + aRemote.mId.Construct(remoteId); + aRemote.mType.Construct(RTCStatsType::Remote_outbound_rtp); + ssrc.apply([&](uint32_t aSsrc) { aRemote.mSsrc = aSsrc; }); + aRemote.mKind = kind; + aRemote.mMediaType.Construct( + kind); // mediaType is the old name for kind. + aRemote.mLocalId.Construct(localId); + }; + + auto constructCommonInboundRtpStats = + [&](RTCInboundRtpStreamStats& aLocal) { + aLocal.mTrackIdentifier = recvTrackId; + aLocal.mTimestamp.Construct( + pipeline->GetTimestampMaker().GetNow().ToDom()); + aLocal.mId.Construct(localId); + aLocal.mType.Construct(RTCStatsType::Inbound_rtp); + ssrc.apply([&](uint32_t aSsrc) { aLocal.mSsrc = aSsrc; }); + aLocal.mKind = kind; + aLocal.mMediaType.Construct( + kind); // mediaType is the old name for kind. + if (remoteId.Length()) { + aLocal.mRemoteId.Construct(remoteId); + } + }; + + asAudio.apply([&](auto& aConduit) { + Maybe<webrtc::AudioReceiveStreamInterface::Stats> audioStats = + aConduit->GetReceiverStats(); + if (audioStats.isNothing()) { + return; + } + + if (!audioStats->last_packet_received_timestamp_ms) { + // By spec: "The lifetime of all RTP monitored objects starts + // when the RTP stream is first used: When the first RTP packet + // is sent or received on the SSRC it represents" + return; + } + + // First, fill in remote stat with rtcp sender data, if present. + if (audioStats->last_sender_report_timestamp_ms) { + RTCRemoteOutboundRtpStreamStats remote; + constructCommonRemoteOutboundRtpStats( + remote, + RTCStatsTimestamp::FromNtp( + aConduit->GetTimestampMaker(), + webrtc::Timestamp::Millis( + *audioStats->last_sender_report_timestamp_ms) + + webrtc::TimeDelta::Seconds(webrtc::kNtpJan1970)) + .ToDom()); + remote.mPacketsSent.Construct( + audioStats->sender_reports_packets_sent); + remote.mBytesSent.Construct( + audioStats->sender_reports_bytes_sent); + remote.mRemoteTimestamp.Construct( + *audioStats->last_sender_report_remote_timestamp_ms); + if (!report->mRemoteOutboundRtpStreamStats.AppendElement( + std::move(remote), fallible)) { + mozalloc_handle_oom(0); + } + } + + // Then, fill in local side (with cross-link to remote only if + // present) + RTCInboundRtpStreamStats local; + constructCommonInboundRtpStats(local); + local.mJitter.Construct(audioStats->jitter_ms / 1000.0); + local.mPacketsLost.Construct(audioStats->packets_lost); + local.mPacketsReceived.Construct(audioStats->packets_rcvd); + local.mPacketsDiscarded.Construct(audioStats->packets_discarded); + local.mBytesReceived.Construct(audioStats->payload_bytes_rcvd); + // Always missing from libwebrtc stats + // if (audioStats->estimated_playout_ntp_timestamp_ms) { + // local.mEstimatedPlayoutTimestamp.Construct( + // RTCStatsTimestamp::FromNtp( + // aConduit->GetTimestampMaker(), + // webrtc::Timestamp::Millis( + // *audioStats->estimated_playout_ntp_timestamp_ms)) + // .ToDom()); + // } + local.mJitterBufferDelay.Construct( + audioStats->jitter_buffer_delay_seconds); + local.mJitterBufferEmittedCount.Construct( + audioStats->jitter_buffer_emitted_count); + local.mTotalSamplesReceived.Construct( + audioStats->total_samples_received); + local.mConcealedSamples.Construct(audioStats->concealed_samples); + local.mSilentConcealedSamples.Construct( + audioStats->silent_concealed_samples); + if (audioStats->last_packet_received_timestamp_ms) { + local.mLastPacketReceivedTimestamp.Construct( + RTCStatsTimestamp::FromNtp( + aConduit->GetTimestampMaker(), + webrtc::Timestamp::Millis( + *audioStats->last_packet_received_timestamp_ms) + + webrtc::TimeDelta::Seconds(webrtc::kNtpJan1970)) + .ToDom()); + } + local.mHeaderBytesReceived.Construct( + audioStats->header_and_padding_bytes_rcvd); + local.mFecPacketsReceived.Construct( + audioStats->fec_packets_received); + local.mFecPacketsDiscarded.Construct( + audioStats->fec_packets_discarded); + local.mConcealmentEvents.Construct( + audioStats->concealment_events); + + local.mInsertedSamplesForDeceleration.Construct( + audioStats->inserted_samples_for_deceleration); + local.mRemovedSamplesForAcceleration.Construct( + audioStats->removed_samples_for_acceleration); + if (audioStats->audio_level >= 0 && + audioStats->audio_level <= 32767) { + local.mAudioLevel.Construct(audioStats->audio_level / 32767.0); + } + local.mTotalAudioEnergy.Construct( + audioStats->total_output_energy); + local.mTotalSamplesDuration.Construct( + audioStats->total_output_duration); + + if (!report->mInboundRtpStreamStats.AppendElement( + std::move(local), fallible)) { + mozalloc_handle_oom(0); + } + }); + + asVideo.apply([&](auto& aConduit) { + Maybe<webrtc::VideoReceiveStreamInterface::Stats> videoStats = + aConduit->GetReceiverStats(); + if (videoStats.isNothing()) { + return; + } + + if (!videoStats->rtp_stats.last_packet_received_timestamp_ms) { + // By spec: "The lifetime of all RTP monitored objects starts + // when the RTP stream is first used: When the first RTP packet + // is sent or received on the SSRC it represents" + return; + } + + // First, fill in remote stat with rtcp sender data, if present. + if (videoStats->rtcp_sender_ntp_timestamp_ms) { + RTCRemoteOutboundRtpStreamStats remote; + constructCommonRemoteOutboundRtpStats( + remote, RTCStatsTimestamp::FromNtp( + aConduit->GetTimestampMaker(), + webrtc::Timestamp::Millis( + videoStats->rtcp_sender_ntp_timestamp_ms)) + .ToDom()); + remote.mPacketsSent.Construct( + videoStats->rtcp_sender_packets_sent); + remote.mBytesSent.Construct( + videoStats->rtcp_sender_octets_sent); + remote.mRemoteTimestamp.Construct( + (webrtc::TimeDelta::Millis( + videoStats->rtcp_sender_remote_ntp_timestamp_ms) - + webrtc::TimeDelta::Seconds(webrtc::kNtpJan1970)) + .ms()); + if (!report->mRemoteOutboundRtpStreamStats.AppendElement( + std::move(remote), fallible)) { + mozalloc_handle_oom(0); + } + } + + // Then, fill in local side (with cross-link to remote only if + // present) + RTCInboundRtpStreamStats local; + constructCommonInboundRtpStats(local); + local.mJitter.Construct( + static_cast<double>(videoStats->rtp_stats.jitter) / + webrtc::kVideoPayloadTypeFrequency); + local.mPacketsLost.Construct(videoStats->rtp_stats.packets_lost); + local.mPacketsReceived.Construct( + videoStats->rtp_stats.packet_counter.packets); + local.mPacketsDiscarded.Construct(videoStats->packets_discarded); + local.mDiscardedPackets.Construct(videoStats->packets_discarded); + local.mBytesReceived.Construct( + videoStats->rtp_stats.packet_counter.payload_bytes); + + // Fill in packet type statistics + local.mNackCount.Construct( + videoStats->rtcp_packet_type_counts.nack_packets); + local.mFirCount.Construct( + videoStats->rtcp_packet_type_counts.fir_packets); + local.mPliCount.Construct( + videoStats->rtcp_packet_type_counts.pli_packets); + + // Lastly, fill in video decoder stats + local.mFramesDecoded.Construct(videoStats->frames_decoded); + + local.mFramesPerSecond.Construct(videoStats->decode_frame_rate); + local.mFrameWidth.Construct(videoStats->width); + local.mFrameHeight.Construct(videoStats->height); + // XXX: key_frames + delta_frames may undercount frames because + // they were dropped in FrameBuffer::InsertFrame. (bug 1766553) + local.mFramesReceived.Construct( + videoStats->frame_counts.key_frames + + videoStats->frame_counts.delta_frames); + local.mJitterBufferDelay.Construct( + videoStats->jitter_buffer_delay_seconds); + local.mJitterBufferEmittedCount.Construct( + videoStats->jitter_buffer_emitted_count); + + if (videoStats->qp_sum) { + local.mQpSum.Construct(videoStats->qp_sum.value()); + } + local.mTotalDecodeTime.Construct( + double(videoStats->total_decode_time.ms()) / 1000); + local.mTotalInterFrameDelay.Construct( + videoStats->total_inter_frame_delay); + local.mTotalSquaredInterFrameDelay.Construct( + videoStats->total_squared_inter_frame_delay); + if (videoStats->rtp_stats.last_packet_received_timestamp_ms) { + local.mLastPacketReceivedTimestamp.Construct( + RTCStatsTimestamp::FromNtp( + aConduit->GetTimestampMaker(), + webrtc::Timestamp::Millis( + *videoStats->rtp_stats + .last_packet_received_timestamp_ms) + + webrtc::TimeDelta::Seconds(webrtc::kNtpJan1970)) + .ToDom()); + } + local.mHeaderBytesReceived.Construct( + videoStats->rtp_stats.packet_counter.header_bytes + + videoStats->rtp_stats.packet_counter.padding_bytes); + local.mTotalProcessingDelay.Construct( + videoStats->total_processing_delay.seconds<double>()); + /* + * Potential new stats that are now available upstream + .if (videoStats->estimated_playout_ntp_timestamp_ms) { + local.mEstimatedPlayoutTimestamp.Construct( + RTCStatsTimestamp::FromNtp( + aConduit->GetTimestampMaker(), + webrtc::Timestamp::Millis( + *videoStats->estimated_playout_ntp_timestamp_ms)) + .ToDom()); + } + */ + // Not including frames dropped in the rendering pipe, which + // is not of webrtc's concern anyway?! + local.mFramesDropped.Construct(videoStats->frames_dropped); + if (!report->mInboundRtpStreamStats.AppendElement( + std::move(local), fallible)) { + mozalloc_handle_oom(0); + } + }); + return RTCStatsPromise::CreateAndResolve(std::move(report), + __func__); + }) + ->Then( + mStsThread, __func__, + [pipeline = mPipeline](UniquePtr<RTCStatsCollection> aReport) { + // Fill in Contributing Source statistics + if (!aReport->mInboundRtpStreamStats.IsEmpty() && + aReport->mInboundRtpStreamStats[0].mId.WasPassed()) { + pipeline->GetContributingSourceStats( + aReport->mInboundRtpStreamStats[0].mId.Value(), + aReport->mRtpContributingSourceStats); + } + return RTCStatsPromise::CreateAndResolve(std::move(aReport), + __func__); + }, + [] { + MOZ_CRASH("Unexpected reject"); + return RTCStatsPromise::CreateAndReject(NS_ERROR_UNEXPECTED, + __func__); + })); + + if (!aSkipIceStats && GetJsepTransceiver().mTransport.mComponents) { + promises.AppendElement(mTransportHandler->GetIceStats( + GetJsepTransceiver().mTransport.mTransportId, + mPipeline->GetTimestampMaker().GetNow().ToDom())); + } + + return promises; +} + +void RTCRtpReceiver::SetJitterBufferTarget( + const Nullable<DOMHighResTimeStamp>& aTargetMs, ErrorResult& aError) { + // Spec says jitter buffer target cannot be negative or larger than 4000 + // milliseconds and to throw RangeError if it is. If an invalid value is + // received we return early to preserve the current JitterBufferTarget + // internal slot and jitter buffer values. + if (mPipeline && mPipeline->mConduit) { + if (!aTargetMs.IsNull() && + (aTargetMs.Value() < 0.0 || aTargetMs.Value() > 4000.0)) { + aError.ThrowRangeError<MSG_VALUE_OUT_OF_RANGE>("jitterBufferTarget"); + return; + } + + mJitterBufferTarget.reset(); + + if (!aTargetMs.IsNull()) { + mJitterBufferTarget = Some(aTargetMs.Value()); + } + // If aJitterBufferTarget is null then we are resetting the jitter buffer so + // pass the default target of 0.0. + mPipeline->mConduit->SetJitterBufferTarget( + mJitterBufferTarget.valueOr(0.0)); + } +} + +void RTCRtpReceiver::GetContributingSources( + nsTArray<RTCRtpContributingSource>& aSources) { + // Duplicate code... + if (mPipeline && mPipeline->mConduit) { + nsTArray<dom::RTCRtpSourceEntry> sources; + mPipeline->mConduit->GetRtpSources(sources); + sources.RemoveElementsBy([](const dom::RTCRtpSourceEntry& aEntry) { + return aEntry.mSourceType != dom::RTCRtpSourceEntryType::Contributing; + }); + aSources.ReplaceElementsAt(0, aSources.Length(), sources.Elements(), + sources.Length()); + } +} + +void RTCRtpReceiver::GetSynchronizationSources( + nsTArray<dom::RTCRtpSynchronizationSource>& aSources) { + // Duplicate code... + if (mPipeline && mPipeline->mConduit) { + nsTArray<dom::RTCRtpSourceEntry> sources; + mPipeline->mConduit->GetRtpSources(sources); + sources.RemoveElementsBy([](const dom::RTCRtpSourceEntry& aEntry) { + return aEntry.mSourceType != dom::RTCRtpSourceEntryType::Synchronization; + }); + aSources.ReplaceElementsAt(0, aSources.Length(), sources.Elements(), + sources.Length()); + } +} + +nsPIDOMWindowInner* RTCRtpReceiver::GetParentObject() const { return mWindow; } + +void RTCRtpReceiver::Shutdown() { + MOZ_ASSERT(NS_IsMainThread()); + mWatchManager.Shutdown(); + if (mPipeline) { + mPipeline->Shutdown(); + mPipeline = nullptr; + } + if (mTrackSource) { + mTrackSource->Destroy(); + } + mCallThread = nullptr; + mRtcpByeListener.DisconnectIfExists(); + mRtcpTimeoutListener.DisconnectIfExists(); + mUnmuteListener.DisconnectIfExists(); +} + +void RTCRtpReceiver::BreakCycles() { + mWindow = nullptr; + mPc = nullptr; + mTrack = nullptr; + mTrackSource = nullptr; +} + +void RTCRtpReceiver::UpdateTransport() { + MOZ_ASSERT(NS_IsMainThread()); + if (!mHaveSetupTransport) { + mPipeline->SetLevel(GetJsepTransceiver().GetLevel()); + mHaveSetupTransport = true; + } + + UniquePtr<MediaPipelineFilter> filter; + + auto const& details = GetJsepTransceiver().mRecvTrack.GetNegotiatedDetails(); + if (GetJsepTransceiver().HasBundleLevel() && details) { + std::vector<webrtc::RtpExtension> extmaps; + details->ForEachRTPHeaderExtension( + [&extmaps](const SdpExtmapAttributeList::Extmap& extmap) { + extmaps.emplace_back(extmap.extensionname, extmap.entry); + }); + filter = MakeUnique<MediaPipelineFilter>(extmaps); + + // Add remote SSRCs so we can distinguish which RTP packets actually + // belong to this pipeline (also RTCP sender reports). + for (uint32_t ssrc : GetJsepTransceiver().mRecvTrack.GetSsrcs()) { + filter->AddRemoteSSRC(ssrc); + } + for (uint32_t ssrc : GetJsepTransceiver().mRecvTrack.GetRtxSsrcs()) { + filter->AddRemoteSSRC(ssrc); + } + auto mid = Maybe<std::string>(); + if (GetMid() != "") { + mid = Some(GetMid()); + } + filter->SetRemoteMediaStreamId(mid); + + // Add unique payload types as a last-ditch fallback + auto uniquePts = GetJsepTransceiver() + .mRecvTrack.GetNegotiatedDetails() + ->GetUniquePayloadTypes(); + for (unsigned char& uniquePt : uniquePts) { + filter->AddUniquePT(uniquePt); + } + } + + mPipeline->UpdateTransport_m(GetJsepTransceiver().mTransport.mTransportId, + std::move(filter)); +} + +void RTCRtpReceiver::UpdateConduit() { + if (mPipeline->mConduit->type() == MediaSessionConduit::VIDEO) { + UpdateVideoConduit(); + } else { + UpdateAudioConduit(); + } + + if ((mReceiving = mTransceiver->IsReceiving())) { + mHaveStartedReceiving = true; + } +} + +void RTCRtpReceiver::UpdateVideoConduit() { + RefPtr<VideoSessionConduit> conduit = + *mPipeline->mConduit->AsVideoSessionConduit(); + + // NOTE(pkerr) - this is new behavior. Needed because the + // CreateVideoReceiveStream method of the Call API will assert (in debug) + // and fail if a value is not provided for the remote_ssrc that will be used + // by the far-end sender. + if (!GetJsepTransceiver().mRecvTrack.GetSsrcs().empty()) { + MOZ_LOG(gReceiverLog, LogLevel::Debug, + ("%s[%s]: %s Setting remote SSRC %u", mPc->GetHandle().c_str(), + GetMid().c_str(), __FUNCTION__, + GetJsepTransceiver().mRecvTrack.GetSsrcs().front())); + uint32_t rtxSsrc = + GetJsepTransceiver().mRecvTrack.GetRtxSsrcs().empty() + ? 0 + : GetJsepTransceiver().mRecvTrack.GetRtxSsrcs().front(); + mSsrc = GetJsepTransceiver().mRecvTrack.GetSsrcs().front(); + mVideoRtxSsrc = rtxSsrc; + + // TODO (bug 1423041) once we pay attention to receiving MID's in RTP + // packets (see bug 1405495) we could make this depending on the presence of + // MID in the RTP packets instead of relying on the signaling. + // In any case, do not disable SSRC changes if no SSRCs were negotiated + if (GetJsepTransceiver().HasBundleLevel() && + (!GetJsepTransceiver().mRecvTrack.GetNegotiatedDetails() || + !GetJsepTransceiver().mRecvTrack.GetNegotiatedDetails()->GetExt( + webrtc::RtpExtension::kMidUri))) { + mCallThread->Dispatch( + NewRunnableMethod("VideoSessionConduit::DisableSsrcChanges", conduit, + &VideoSessionConduit::DisableSsrcChanges)); + } + } + + if (GetJsepTransceiver().mRecvTrack.GetNegotiatedDetails() && + GetJsepTransceiver().mRecvTrack.GetActive()) { + const auto& details( + *GetJsepTransceiver().mRecvTrack.GetNegotiatedDetails()); + + { + std::vector<webrtc::RtpExtension> extmaps; + // @@NG read extmap from track + details.ForEachRTPHeaderExtension( + [&extmaps](const SdpExtmapAttributeList::Extmap& extmap) { + extmaps.emplace_back(extmap.extensionname, extmap.entry); + }); + mLocalRtpExtensions = extmaps; + } + + std::vector<VideoCodecConfig> configs; + RTCRtpTransceiver::NegotiatedDetailsToVideoCodecConfigs(details, &configs); + if (configs.empty()) { + // TODO: Are we supposed to plumb this error back to JS? This does not + // seem like a failure to set an answer, it just means that codec + // negotiation failed. For now, we're just doing the same thing we do + // if negotiation as a whole failed. + MOZ_LOG(gReceiverLog, LogLevel::Error, + ("%s[%s]: %s No video codecs were negotiated (recv).", + mPc->GetHandle().c_str(), GetMid().c_str(), __FUNCTION__)); + return; + } + + mVideoCodecs = configs; + mVideoRtpRtcpConfig = Some(details.GetRtpRtcpConfig()); + } +} + +void RTCRtpReceiver::UpdateAudioConduit() { + RefPtr<AudioSessionConduit> conduit = + *mPipeline->mConduit->AsAudioSessionConduit(); + + if (!GetJsepTransceiver().mRecvTrack.GetSsrcs().empty()) { + MOZ_LOG(gReceiverLog, LogLevel::Debug, + ("%s[%s]: %s Setting remote SSRC %u", mPc->GetHandle().c_str(), + GetMid().c_str(), __FUNCTION__, + GetJsepTransceiver().mRecvTrack.GetSsrcs().front())); + mSsrc = GetJsepTransceiver().mRecvTrack.GetSsrcs().front(); + + // TODO (bug 1423041) once we pay attention to receiving MID's in RTP + // packets (see bug 1405495) we could make this depending on the presence of + // MID in the RTP packets instead of relying on the signaling. + // In any case, do not disable SSRC changes if no SSRCs were negotiated + if (GetJsepTransceiver().HasBundleLevel() && + (!GetJsepTransceiver().mRecvTrack.GetNegotiatedDetails() || + !GetJsepTransceiver().mRecvTrack.GetNegotiatedDetails()->GetExt( + webrtc::RtpExtension::kMidUri))) { + mCallThread->Dispatch( + NewRunnableMethod("AudioSessionConduit::DisableSsrcChanges", conduit, + &AudioSessionConduit::DisableSsrcChanges)); + } + } + + if (GetJsepTransceiver().mRecvTrack.GetNegotiatedDetails() && + GetJsepTransceiver().mRecvTrack.GetActive()) { + const auto& details( + *GetJsepTransceiver().mRecvTrack.GetNegotiatedDetails()); + std::vector<AudioCodecConfig> configs; + RTCRtpTransceiver::NegotiatedDetailsToAudioCodecConfigs(details, &configs); + if (configs.empty()) { + // TODO: Are we supposed to plumb this error back to JS? This does not + // seem like a failure to set an answer, it just means that codec + // negotiation failed. For now, we're just doing the same thing we do + // if negotiation as a whole failed. + MOZ_LOG(gReceiverLog, LogLevel::Error, + ("%s[%s]: %s No audio codecs were negotiated (recv)", + mPc->GetHandle().c_str(), GetMid().c_str(), __FUNCTION__)); + return; + } + + // Ensure conduit knows about extensions prior to creating streams + { + std::vector<webrtc::RtpExtension> extmaps; + // @@NG read extmap from track + details.ForEachRTPHeaderExtension( + [&extmaps](const SdpExtmapAttributeList::Extmap& extmap) { + extmaps.emplace_back(extmap.extensionname, extmap.entry); + }); + mLocalRtpExtensions = extmaps; + } + + mAudioCodecs = configs; + } +} + +void RTCRtpReceiver::Stop() { + MOZ_ASSERT(mTransceiver->Stopped()); + mReceiving = false; +} + +bool RTCRtpReceiver::HasTrack(const dom::MediaStreamTrack* aTrack) const { + return !aTrack || (mTrack == aTrack); +} + +void RTCRtpReceiver::SyncFromJsep(const JsepTransceiver& aJsepTransceiver) { + if (!mPipeline) { + return; + } + + // Spec says we set [[Receptive]] to true on sLD(sendrecv/recvonly), and to + // false on sRD(recvonly/inactive), sLD(sendonly/inactive), or when stop() + // is called. + bool wasReceptive = mReceptive; + mReceptive = aJsepTransceiver.mRecvTrack.GetReceptive(); + if (!wasReceptive && mReceptive) { + mUnmuteListener = mPipeline->mConduit->RtpPacketEvent().Connect( + GetMainThreadSerialEventTarget(), this, &RTCRtpReceiver::OnRtpPacket); + } else if (wasReceptive && !mReceptive) { + mUnmuteListener.DisconnectIfExists(); + } +} + +void RTCRtpReceiver::SyncToJsep(JsepTransceiver& aJsepTransceiver) const {} + +void RTCRtpReceiver::UpdateStreams(StreamAssociationChanges* aChanges) { + // We don't sort and use set_difference, because we need to report the + // added/removed streams in the order that they appear in the SDP. + std::set<std::string> newIds( + GetJsepTransceiver().mRecvTrack.GetStreamIds().begin(), + GetJsepTransceiver().mRecvTrack.GetStreamIds().end()); + MOZ_ASSERT(GetJsepTransceiver().mRecvTrack.GetRemoteSetSendBit() || + newIds.empty()); + bool needsTrackEvent = false; + for (const auto& id : mStreamIds) { + if (!newIds.count(id)) { + aChanges->mStreamAssociationsRemoved.push_back({mTrack, id}); + } + } + + std::set<std::string> oldIds(mStreamIds.begin(), mStreamIds.end()); + for (const auto& id : GetJsepTransceiver().mRecvTrack.GetStreamIds()) { + if (!oldIds.count(id)) { + needsTrackEvent = true; + aChanges->mStreamAssociationsAdded.push_back({mTrack, id}); + } + } + + mStreamIds = GetJsepTransceiver().mRecvTrack.GetStreamIds(); + + if (mRemoteSetSendBit != + GetJsepTransceiver().mRecvTrack.GetRemoteSetSendBit()) { + mRemoteSetSendBit = GetJsepTransceiver().mRecvTrack.GetRemoteSetSendBit(); + if (mRemoteSetSendBit) { + needsTrackEvent = true; + } else { + aChanges->mReceiversToMute.push_back(this); + } + } + + if (needsTrackEvent) { + aChanges->mTrackEvents.push_back({this, mStreamIds}); + } +} + +void RTCRtpReceiver::UpdatePrincipalPrivacy(PrincipalPrivacy aPrivacy) { + if (!mPipeline) { + return; + } + + if (aPrivacy != PrincipalPrivacy::Private) { + return; + } + + mPipeline->SetPrivatePrincipal(GetPrincipalHandle(mWindow, aPrivacy)); +} + +// test-only: adds fake CSRCs and audio data +void RTCRtpReceiver::MozInsertAudioLevelForContributingSource( + const uint32_t aSource, const DOMHighResTimeStamp aTimestamp, + const uint32_t aRtpTimestamp, const bool aHasLevel, const uint8_t aLevel) { + if (!mPipeline || mPipeline->IsVideo() || !mPipeline->mConduit) { + return; + } + mPipeline->mConduit->InsertAudioLevelForContributingSource( + aSource, aTimestamp, aRtpTimestamp, aHasLevel, aLevel); +} + +void RTCRtpReceiver::OnRtcpBye() { mReceiveTrackMute = true; } + +void RTCRtpReceiver::OnRtcpTimeout() { mReceiveTrackMute = true; } + +void RTCRtpReceiver::SetTrackMuteFromRemoteSdp() { + MOZ_ASSERT(!mReceptive, + "PeerConnectionImpl should have blocked unmute events prior to " + "firing mute"); + mReceiveTrackMute = true; + // Set the mute state (and fire the mute event) synchronously. Unmute is + // handled asynchronously after receiving RTP packets. + UpdateReceiveTrackMute(); + MOZ_ASSERT(mTrack->Muted(), "Muted state was indeed set synchronously"); +} + +void RTCRtpReceiver::OnRtpPacket() { + MOZ_ASSERT(mReceptive, "We should not be registered unless this is set!"); + // We should be registered since we're currently getting a callback. + mUnmuteListener.Disconnect(); + if (mReceptive) { + mReceiveTrackMute = false; + } +} + +void RTCRtpReceiver::UpdateReceiveTrackMute() { + if (!mTrack) { + return; + } + if (!mTrackSource) { + return; + } + // This sets the muted state for mTrack and all its clones. + // Idempotent -- only reacts to changes. + mTrackSource->SetMuted(mReceiveTrackMute); +} + +std::string RTCRtpReceiver::GetMid() const { + return mTransceiver->GetMidAscii(); +} + +JsepTransceiver& RTCRtpReceiver::GetJsepTransceiver() { + MOZ_ASSERT(mTransceiver); + return mTransceiver->GetJsepTransceiver(); +} + +const JsepTransceiver& RTCRtpReceiver::GetJsepTransceiver() const { + MOZ_ASSERT(mTransceiver); + return mTransceiver->GetJsepTransceiver(); +} + +} // namespace mozilla::dom + +#undef LOGTAG diff --git a/dom/media/webrtc/jsapi/RTCRtpReceiver.h b/dom/media/webrtc/jsapi/RTCRtpReceiver.h new file mode 100644 index 0000000000..2c050bceb1 --- /dev/null +++ b/dom/media/webrtc/jsapi/RTCRtpReceiver.h @@ -0,0 +1,198 @@ +/* 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/. */ + +#ifndef _RTCRtpReceiver_h_ +#define _RTCRtpReceiver_h_ + +#include "nsISupports.h" +#include "nsWrapperCache.h" +#include "mozilla/RefPtr.h" +#include "mozilla/StateMirroring.h" +#include "mozilla/Maybe.h" +#include "js/RootingAPI.h" +#include "libwebrtcglue/RtpRtcpConfig.h" +#include "nsTArray.h" +#include "mozilla/dom/RTCRtpCapabilitiesBinding.h" +#include "mozilla/dom/RTCStatsReportBinding.h" +#include "PerformanceRecorder.h" +#include "RTCStatsReport.h" +#include "transportbridge/MediaPipeline.h" +#include <vector> + +class nsPIDOMWindowInner; + +namespace mozilla { +class MediaSessionConduit; +class MediaTransportHandler; +class JsepTransceiver; +class PeerConnectionImpl; +enum class PrincipalPrivacy : uint8_t; +class RemoteTrackSource; + +namespace dom { +class MediaStreamTrack; +class Promise; +class RTCDtlsTransport; +struct RTCRtpCapabilities; +struct RTCRtpContributingSource; +struct RTCRtpSynchronizationSource; +class RTCRtpTransceiver; + +class RTCRtpReceiver : public nsISupports, + public nsWrapperCache, + public MediaPipelineReceiveControlInterface { + public: + RTCRtpReceiver(nsPIDOMWindowInner* aWindow, PrincipalPrivacy aPrivacy, + PeerConnectionImpl* aPc, + MediaTransportHandler* aTransportHandler, + AbstractThread* aCallThread, nsISerialEventTarget* aStsThread, + MediaSessionConduit* aConduit, RTCRtpTransceiver* aTransceiver, + const TrackingId& aTrackingId); + + // nsISupports + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + NS_DECL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(RTCRtpReceiver) + + JSObject* WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) override; + + // webidl + MediaStreamTrack* Track() const { return mTrack; } + RTCDtlsTransport* GetTransport() const; + static void GetCapabilities(const GlobalObject&, const nsAString& aKind, + Nullable<dom::RTCRtpCapabilities>& aResult); + already_AddRefed<Promise> GetStats(ErrorResult& aError); + void GetContributingSources( + nsTArray<dom::RTCRtpContributingSource>& aSources); + void GetSynchronizationSources( + nsTArray<dom::RTCRtpSynchronizationSource>& aSources); + // test-only: insert fake CSRCs and audio levels for testing + void MozInsertAudioLevelForContributingSource( + const uint32_t aSource, const DOMHighResTimeStamp aTimestamp, + const uint32_t aRtpTimestamp, const bool aHasLevel, const uint8_t aLevel); + + nsPIDOMWindowInner* GetParentObject() const; + nsTArray<RefPtr<RTCStatsPromise>> GetStatsInternal( + bool aSkipIceStats = false); + Nullable<DOMHighResTimeStamp> GetJitterBufferTarget( + ErrorResult& aError) const { + return mJitterBufferTarget.isSome() ? Nullable(mJitterBufferTarget.value()) + : Nullable<DOMHighResTimeStamp>(); + } + void SetJitterBufferTarget(const Nullable<DOMHighResTimeStamp>& aTargetMs, + ErrorResult& aError); + + void Shutdown(); + void BreakCycles(); + // Terminal state, reached through stopping RTCRtpTransceiver. + void Stop(); + bool HasTrack(const dom::MediaStreamTrack* aTrack) const; + void SyncToJsep(JsepTransceiver& aJsepTransceiver) const; + void SyncFromJsep(const JsepTransceiver& aJsepTransceiver); + const std::vector<std::string>& GetStreamIds() const { return mStreamIds; } + + struct StreamAssociation { + RefPtr<MediaStreamTrack> mTrack; + std::string mStreamId; + }; + + struct TrackEventInfo { + RefPtr<RTCRtpReceiver> mReceiver; + std::vector<std::string> mStreamIds; + }; + + struct StreamAssociationChanges { + std::vector<RefPtr<RTCRtpReceiver>> mReceiversToMute; + std::vector<StreamAssociation> mStreamAssociationsRemoved; + std::vector<StreamAssociation> mStreamAssociationsAdded; + std::vector<TrackEventInfo> mTrackEvents; + }; + + // This is called when we set an answer (ie; when the transport is finalized). + void UpdateTransport(); + void UpdateConduit(); + + // This is called when we set a remote description; may be an offer or answer. + void UpdateStreams(StreamAssociationChanges* aChanges); + + // Called when the privacy-needed state changes on the fly, as a result of + // ALPN negotiation. + void UpdatePrincipalPrivacy(PrincipalPrivacy aPrivacy); + + void OnRtcpBye(); + void OnRtcpTimeout(); + + void SetTrackMuteFromRemoteSdp(); + void OnRtpPacket(); + void UpdateUnmuteBlockingState(); + void UpdateReceiveTrackMute(); + + AbstractCanonical<Ssrc>* CanonicalSsrc() { return &mSsrc; } + AbstractCanonical<Ssrc>* CanonicalVideoRtxSsrc() { return &mVideoRtxSsrc; } + AbstractCanonical<RtpExtList>* CanonicalLocalRtpExtensions() { + return &mLocalRtpExtensions; + } + + AbstractCanonical<std::vector<AudioCodecConfig>>* CanonicalAudioCodecs() { + return &mAudioCodecs; + } + + AbstractCanonical<std::vector<VideoCodecConfig>>* CanonicalVideoCodecs() { + return &mVideoCodecs; + } + AbstractCanonical<Maybe<RtpRtcpConfig>>* CanonicalVideoRtpRtcpConfig() { + return &mVideoRtpRtcpConfig; + } + AbstractCanonical<bool>* CanonicalReceiving() override { return &mReceiving; } + + private: + virtual ~RTCRtpReceiver(); + + void UpdateVideoConduit(); + void UpdateAudioConduit(); + + std::string GetMid() const; + JsepTransceiver& GetJsepTransceiver(); + const JsepTransceiver& GetJsepTransceiver() const; + + WatchManager<RTCRtpReceiver> mWatchManager; + nsCOMPtr<nsPIDOMWindowInner> mWindow; + RefPtr<PeerConnectionImpl> mPc; + bool mHaveStartedReceiving = false; + bool mHaveSetupTransport = false; + RefPtr<AbstractThread> mCallThread; + nsCOMPtr<nsISerialEventTarget> mStsThread; + RefPtr<dom::MediaStreamTrack> mTrack; + RefPtr<RemoteTrackSource> mTrackSource; + RefPtr<MediaPipelineReceive> mPipeline; + RefPtr<MediaTransportHandler> mTransportHandler; + RefPtr<RTCRtpTransceiver> mTransceiver; + // This is [[AssociatedRemoteMediaStreams]], basically. We do not keep the + // streams themselves here, because that would require this object to know + // where the stream list for the whole RTCPeerConnection lives.. + std::vector<std::string> mStreamIds; + bool mRemoteSetSendBit = false; + Watchable<bool> mReceiveTrackMute{true, "RTCRtpReceiver::mReceiveTrackMute"}; + // This corresponds to the [[Receptive]] slot on RTCRtpTransceiver. + // Its only purpose is suppressing unmute events if true. + bool mReceptive = false; + // This is the [[JitterBufferTarget]] internal slot. + Maybe<DOMHighResTimeStamp> mJitterBufferTarget; + + MediaEventListener mRtcpByeListener; + MediaEventListener mRtcpTimeoutListener; + MediaEventListener mUnmuteListener; + + Canonical<Ssrc> mSsrc; + Canonical<Ssrc> mVideoRtxSsrc; + Canonical<RtpExtList> mLocalRtpExtensions; + Canonical<std::vector<AudioCodecConfig>> mAudioCodecs; + Canonical<std::vector<VideoCodecConfig>> mVideoCodecs; + Canonical<Maybe<RtpRtcpConfig>> mVideoRtpRtcpConfig; + Canonical<bool> mReceiving; +}; + +} // namespace dom +} // namespace mozilla +#endif // _RTCRtpReceiver_h_ diff --git a/dom/media/webrtc/jsapi/RTCRtpSender.cpp b/dom/media/webrtc/jsapi/RTCRtpSender.cpp new file mode 100644 index 0000000000..568a83e8d1 --- /dev/null +++ b/dom/media/webrtc/jsapi/RTCRtpSender.cpp @@ -0,0 +1,1654 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "RTCRtpSender.h" +#include "transport/logging.h" +#include "mozilla/dom/MediaStreamTrack.h" +#include "mozilla/dom/Promise.h" +#include "mozilla/glean/GleanMetrics.h" +#include "nsPIDOMWindow.h" +#include "nsString.h" +#include "mozilla/dom/VideoStreamTrack.h" +#include "jsep/JsepTransceiver.h" +#include "mozilla/dom/RTCRtpSenderBinding.h" +#include "RTCStatsReport.h" +#include "mozilla/Preferences.h" +#include "RTCRtpTransceiver.h" +#include "PeerConnectionImpl.h" +#include "libwebrtcglue/AudioConduit.h" +#include <vector> +#include "call/call.h" + +namespace mozilla::dom { + +LazyLogModule gSenderLog("RTCRtpSender"); + +NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(RTCRtpSender) +NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(RTCRtpSender) + // We do not do anything here, we wait for BreakCycles to be called + NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER +NS_IMPL_CYCLE_COLLECTION_UNLINK_END +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(RTCRtpSender) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mWindow, mPc, mSenderTrack, mTransceiver, + mStreams, mDtmf) +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END + +NS_IMPL_CYCLE_COLLECTING_ADDREF(RTCRtpSender) +NS_IMPL_CYCLE_COLLECTING_RELEASE(RTCRtpSender) +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(RTCRtpSender) + NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY + NS_INTERFACE_MAP_ENTRY(nsISupports) +NS_INTERFACE_MAP_END + +#define INIT_CANONICAL(name, val) \ + name(AbstractThread::MainThread(), val, "RTCRtpSender::" #name " (Canonical)") + +RTCRtpSender::RTCRtpSender(nsPIDOMWindowInner* aWindow, PeerConnectionImpl* aPc, + MediaTransportHandler* aTransportHandler, + AbstractThread* aCallThread, + nsISerialEventTarget* aStsThread, + MediaSessionConduit* aConduit, + dom::MediaStreamTrack* aTrack, + const Sequence<RTCRtpEncodingParameters>& aEncodings, + RTCRtpTransceiver* aTransceiver) + : mWatchManager(this, AbstractThread::MainThread()), + mWindow(aWindow), + mPc(aPc), + mSenderTrack(aTrack), + mTransportHandler(aTransportHandler), + mTransceiver(aTransceiver), + INIT_CANONICAL(mSsrcs, Ssrcs()), + INIT_CANONICAL(mVideoRtxSsrcs, Ssrcs()), + INIT_CANONICAL(mLocalRtpExtensions, RtpExtList()), + INIT_CANONICAL(mAudioCodec, Nothing()), + INIT_CANONICAL(mVideoCodec, Nothing()), + INIT_CANONICAL(mVideoRtpRtcpConfig, Nothing()), + INIT_CANONICAL(mVideoCodecMode, webrtc::VideoCodecMode::kRealtimeVideo), + INIT_CANONICAL(mCname, std::string()), + INIT_CANONICAL(mTransmitting, false) { + mPipeline = new MediaPipelineTransmit( + mPc->GetHandle(), aTransportHandler, aCallThread, aStsThread, + aConduit->type() == MediaSessionConduit::VIDEO, aConduit); + mPipeline->InitControl(this); + + if (aConduit->type() == MediaSessionConduit::AUDIO) { + mDtmf = new RTCDTMFSender(aWindow, mTransceiver); + } + mPipeline->SetTrack(mSenderTrack); + + mozilla::glean::rtcrtpsender::count.Add(1); + + if (mPc->ShouldAllowOldSetParameters()) { + mAllowOldSetParameters = true; + mozilla::glean::rtcrtpsender::count_setparameters_compat.Add(1); + } + + if (aEncodings.Length()) { + // This sender was created by addTransceiver with sendEncodings. + mParameters.mEncodings = aEncodings; + mSimulcastEnvelopeSet = true; + mozilla::glean::rtcrtpsender::used_sendencodings.AddToNumerator(1); + } else { + // This sender was created by addTrack, sRD(offer), or addTransceiver + // without sendEncodings. + RTCRtpEncodingParameters defaultEncoding; + defaultEncoding.mActive = true; + if (aConduit->type() == MediaSessionConduit::VIDEO) { + defaultEncoding.mScaleResolutionDownBy.Construct(1.0f); + } + Unused << mParameters.mEncodings.AppendElement(defaultEncoding, fallible); + UpdateRestorableEncodings(mParameters.mEncodings); + MaybeGetJsepRids(); + } + + if (mDtmf) { + mWatchManager.Watch(mTransmitting, &RTCRtpSender::UpdateDtmfSender); + } +} + +#undef INIT_CANONICAL + +RTCRtpSender::~RTCRtpSender() = default; + +JSObject* RTCRtpSender::WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) { + return RTCRtpSender_Binding::Wrap(aCx, this, aGivenProto); +} + +RTCDtlsTransport* RTCRtpSender::GetTransport() const { + if (!mTransceiver) { + return nullptr; + } + return mTransceiver->GetDtlsTransport(); +} + +RTCDTMFSender* RTCRtpSender::GetDtmf() const { return mDtmf; } + +already_AddRefed<Promise> RTCRtpSender::GetStats(ErrorResult& aError) { + RefPtr<Promise> promise = MakePromise(aError); + if (aError.Failed()) { + return nullptr; + } + if (NS_WARN_IF(!mPipeline)) { + // TODO(bug 1056433): When we stop nulling this out when the PC is closed + // (or when the transceiver is stopped), we can remove this code. We + // resolve instead of reject in order to make this eventual change in + // behavior a little smaller. + promise->MaybeResolve(new RTCStatsReport(mWindow)); + return promise.forget(); + } + + if (!mSenderTrack) { + promise->MaybeResolve(new RTCStatsReport(mWindow)); + return promise.forget(); + } + + mTransceiver->ChainToDomPromiseWithCodecStats(GetStatsInternal(), promise); + return promise.forget(); +} + +nsTArray<RefPtr<dom::RTCStatsPromise>> RTCRtpSender::GetStatsInternal( + bool aSkipIceStats) { + MOZ_ASSERT(NS_IsMainThread()); + nsTArray<RefPtr<RTCStatsPromise>> promises(2); + if (!mSenderTrack || !mPipeline) { + return promises; + } + + nsAutoString trackName; + if (auto track = mPipeline->GetTrack()) { + track->GetId(trackName); + } + + { + // Add bandwidth estimation stats + promises.AppendElement(InvokeAsync( + mPipeline->mCallThread, __func__, + [conduit = mPipeline->mConduit, trackName]() mutable { + auto report = MakeUnique<dom::RTCStatsCollection>(); + Maybe<webrtc::Call::Stats> stats = conduit->GetCallStats(); + stats.apply([&](const auto aStats) { + dom::RTCBandwidthEstimationInternal bw; + bw.mTrackIdentifier = trackName; + bw.mSendBandwidthBps.Construct(aStats.send_bandwidth_bps / 8); + bw.mMaxPaddingBps.Construct(aStats.max_padding_bitrate_bps / 8); + bw.mReceiveBandwidthBps.Construct(aStats.recv_bandwidth_bps / 8); + bw.mPacerDelayMs.Construct(aStats.pacer_delay_ms); + if (aStats.rtt_ms >= 0) { + bw.mRttMs.Construct(aStats.rtt_ms); + } + if (!report->mBandwidthEstimations.AppendElement(std::move(bw), + fallible)) { + mozalloc_handle_oom(0); + } + }); + return RTCStatsPromise::CreateAndResolve(std::move(report), __func__); + })); + } + + promises.AppendElement(InvokeAsync( + mPipeline->mCallThread, __func__, [pipeline = mPipeline, trackName] { + auto report = MakeUnique<dom::RTCStatsCollection>(); + auto asAudio = pipeline->mConduit->AsAudioSessionConduit(); + auto asVideo = pipeline->mConduit->AsVideoSessionConduit(); + + nsString kind = asVideo.isNothing() ? u"audio"_ns : u"video"_ns; + nsString idstr = kind + u"_"_ns; + idstr.AppendInt(static_cast<uint32_t>(pipeline->Level())); + + for (uint32_t ssrc : pipeline->mConduit->GetLocalSSRCs()) { + nsString localId = u"outbound_rtp_"_ns + idstr + u"_"_ns; + localId.AppendInt(ssrc); + nsString remoteId; + Maybe<uint16_t> base_seq = + pipeline->mConduit->RtpSendBaseSeqFor(ssrc); + + auto constructCommonRemoteInboundRtpStats = + [&](RTCRemoteInboundRtpStreamStats& aRemote, + const webrtc::ReportBlockData& aRtcpData) { + remoteId = u"outbound_rtcp_"_ns + idstr + u"_"_ns; + remoteId.AppendInt(ssrc); + aRemote.mTimestamp.Construct( + RTCStatsTimestamp::FromNtp( + pipeline->GetTimestampMaker(), + webrtc::Timestamp::Micros( + aRtcpData.report_block_timestamp_utc_us()) + + webrtc::TimeDelta::Seconds(webrtc::kNtpJan1970)) + .ToDom()); + aRemote.mId.Construct(remoteId); + aRemote.mType.Construct(RTCStatsType::Remote_inbound_rtp); + aRemote.mSsrc = ssrc; + aRemote.mKind = kind; + aRemote.mMediaType.Construct( + kind); // mediaType is the old name for kind. + aRemote.mLocalId.Construct(localId); + if (base_seq) { + if (aRtcpData.report_block() + .extended_highest_sequence_number < *base_seq) { + aRemote.mPacketsReceived.Construct(0); + } else { + aRemote.mPacketsReceived.Construct( + aRtcpData.report_block() + .extended_highest_sequence_number - + aRtcpData.report_block().packets_lost - *base_seq + 1); + } + } + }; + + auto constructCommonOutboundRtpStats = + [&](RTCOutboundRtpStreamStats& aLocal) { + aLocal.mSsrc = ssrc; + aLocal.mTimestamp.Construct( + pipeline->GetTimestampMaker().GetNow().ToDom()); + aLocal.mId.Construct(localId); + aLocal.mType.Construct(RTCStatsType::Outbound_rtp); + aLocal.mKind = kind; + aLocal.mMediaType.Construct( + kind); // mediaType is the old name for kind. + if (remoteId.Length()) { + aLocal.mRemoteId.Construct(remoteId); + } + }; + + asAudio.apply([&](auto& aConduit) { + Maybe<webrtc::AudioSendStream::Stats> audioStats = + aConduit->GetSenderStats(); + if (audioStats.isNothing()) { + return; + } + + if (audioStats->packets_sent == 0) { + // By spec: "The lifetime of all RTP monitored objects starts + // when the RTP stream is first used: When the first RTP packet + // is sent or received on the SSRC it represents" + return; + } + + // First, fill in remote stat with rtcp receiver data, if present. + // ReceiverReports have less information than SenderReports, so fill + // in what we can. + Maybe<webrtc::ReportBlockData> reportBlockData; + { + if (const auto remoteSsrc = aConduit->GetRemoteSSRC(); + remoteSsrc) { + for (auto& data : audioStats->report_block_datas) { + if (data.report_block().source_ssrc == ssrc && + data.report_block().sender_ssrc == *remoteSsrc) { + reportBlockData.emplace(data); + break; + } + } + } + } + reportBlockData.apply([&](auto& aReportBlockData) { + RTCRemoteInboundRtpStreamStats remote; + constructCommonRemoteInboundRtpStats(remote, aReportBlockData); + if (audioStats->jitter_ms >= 0) { + remote.mJitter.Construct(audioStats->jitter_ms / 1000.0); + } + if (audioStats->packets_lost >= 0) { + remote.mPacketsLost.Construct(audioStats->packets_lost); + } + if (audioStats->rtt_ms >= 0) { + remote.mRoundTripTime.Construct( + static_cast<double>(audioStats->rtt_ms) / 1000.0); + } + remote.mFractionLost.Construct(audioStats->fraction_lost); + remote.mTotalRoundTripTime.Construct( + double(aReportBlockData.sum_rtt_ms()) / 1000); + remote.mRoundTripTimeMeasurements.Construct( + aReportBlockData.num_rtts()); + if (!report->mRemoteInboundRtpStreamStats.AppendElement( + std::move(remote), fallible)) { + mozalloc_handle_oom(0); + } + }); + + // Then, fill in local side (with cross-link to remote only if + // present) + RTCOutboundRtpStreamStats local; + constructCommonOutboundRtpStats(local); + local.mPacketsSent.Construct(audioStats->packets_sent); + local.mBytesSent.Construct(audioStats->payload_bytes_sent); + local.mNackCount.Construct( + audioStats->rtcp_packet_type_counts.nack_packets); + local.mHeaderBytesSent.Construct( + audioStats->header_and_padding_bytes_sent); + local.mRetransmittedPacketsSent.Construct( + audioStats->retransmitted_packets_sent); + local.mRetransmittedBytesSent.Construct( + audioStats->retransmitted_bytes_sent); + /* + * Potential new stats that are now available upstream. + * Note: when we last tried exposing this we were getting + * targetBitrate for audio was ending up as 0. We did not + * investigate why. + local.mTargetBitrate.Construct(audioStats->target_bitrate_bps); + */ + if (!report->mOutboundRtpStreamStats.AppendElement(std::move(local), + fallible)) { + mozalloc_handle_oom(0); + } + }); + + asVideo.apply([&](auto& aConduit) { + Maybe<webrtc::VideoSendStream::Stats> videoStats = + aConduit->GetSenderStats(); + if (videoStats.isNothing()) { + return; + } + + Maybe<webrtc::VideoSendStream::StreamStats> streamStats; + auto kv = videoStats->substreams.find(ssrc); + if (kv != videoStats->substreams.end()) { + streamStats = Some(kv->second); + } + + if (!streamStats) { + // By spec: "The lifetime of all RTP monitored objects starts + // when the RTP stream is first used: When the first RTP packet + // is sent or received on the SSRC it represents" + return; + } + + aConduit->GetAssociatedLocalRtxSSRC(ssrc).apply( + [&](const auto rtxSsrc) { + auto kv = videoStats->substreams.find(rtxSsrc); + if (kv != videoStats->substreams.end()) { + streamStats->rtp_stats.Add(kv->second.rtp_stats); + } + }); + + if (streamStats->rtp_stats.first_packet_time_ms == -1) { + return; + } + + // First, fill in remote stat with rtcp receiver data, if present. + // ReceiverReports have less information than SenderReports, so fill + // in what we can. + if (streamStats->report_block_data) { + const webrtc::ReportBlockData& rtcpReportData = + *streamStats->report_block_data; + RTCRemoteInboundRtpStreamStats remote; + remote.mJitter.Construct( + static_cast<double>(rtcpReportData.report_block().jitter) / + webrtc::kVideoPayloadTypeFrequency); + remote.mPacketsLost.Construct( + rtcpReportData.report_block().packets_lost); + if (rtcpReportData.has_rtt()) { + remote.mRoundTripTime.Construct( + static_cast<double>(rtcpReportData.last_rtt_ms()) / 1000.0); + } + constructCommonRemoteInboundRtpStats(remote, rtcpReportData); + remote.mTotalRoundTripTime.Construct( + streamStats->report_block_data->sum_rtt_ms() / 1000.0); + remote.mFractionLost.Construct( + static_cast<float>( + rtcpReportData.report_block().fraction_lost) / + (1 << 8)); + remote.mRoundTripTimeMeasurements.Construct( + streamStats->report_block_data->num_rtts()); + if (!report->mRemoteInboundRtpStreamStats.AppendElement( + std::move(remote), fallible)) { + mozalloc_handle_oom(0); + } + } + + // Then, fill in local side (with cross-link to remote only if + // present) + RTCOutboundRtpStreamStats local; + constructCommonOutboundRtpStats(local); + local.mPacketsSent.Construct( + streamStats->rtp_stats.transmitted.packets); + local.mBytesSent.Construct( + streamStats->rtp_stats.transmitted.payload_bytes); + local.mNackCount.Construct( + streamStats->rtcp_packet_type_counts.nack_packets); + local.mFirCount.Construct( + streamStats->rtcp_packet_type_counts.fir_packets); + local.mPliCount.Construct( + streamStats->rtcp_packet_type_counts.pli_packets); + local.mFramesEncoded.Construct(streamStats->frames_encoded); + if (streamStats->qp_sum) { + local.mQpSum.Construct(*streamStats->qp_sum); + } + local.mHeaderBytesSent.Construct( + streamStats->rtp_stats.transmitted.header_bytes + + streamStats->rtp_stats.transmitted.padding_bytes); + local.mRetransmittedPacketsSent.Construct( + streamStats->rtp_stats.retransmitted.packets); + local.mRetransmittedBytesSent.Construct( + streamStats->rtp_stats.retransmitted.payload_bytes); + local.mTotalEncodedBytesTarget.Construct( + videoStats->total_encoded_bytes_target); + local.mFrameWidth.Construct(streamStats->width); + local.mFrameHeight.Construct(streamStats->height); + local.mFramesSent.Construct(streamStats->frames_encoded); + local.mHugeFramesSent.Construct(streamStats->huge_frames_sent); + local.mTotalEncodeTime.Construct( + double(streamStats->total_encode_time_ms) / 1000.); + /* + * Potential new stats that are now available upstream. + local.mTargetBitrate.Construct(videoStats->target_media_bitrate_bps); + */ + if (!report->mOutboundRtpStreamStats.AppendElement(std::move(local), + fallible)) { + mozalloc_handle_oom(0); + } + }); + } + + auto constructCommonMediaSourceStats = + [&](RTCMediaSourceStats& aStats) { + nsString id = u"mediasource_"_ns + idstr + trackName; + aStats.mTimestamp.Construct( + pipeline->GetTimestampMaker().GetNow().ToDom()); + aStats.mId.Construct(id); + aStats.mType.Construct(RTCStatsType::Media_source); + aStats.mTrackIdentifier = trackName; + aStats.mKind = kind; + }; + + // TODO(bug 1804678): Use RTCAudioSourceStats/RTCVideoSourceStats + RTCMediaSourceStats mediaSourceStats; + constructCommonMediaSourceStats(mediaSourceStats); + if (!report->mMediaSourceStats.AppendElement( + std::move(mediaSourceStats), fallible)) { + mozalloc_handle_oom(0); + } + + return RTCStatsPromise::CreateAndResolve(std::move(report), __func__); + })); + + if (!aSkipIceStats && GetJsepTransceiver().mTransport.mComponents) { + promises.AppendElement(mTransportHandler->GetIceStats( + GetJsepTransceiver().mTransport.mTransportId, + mPipeline->GetTimestampMaker().GetNow().ToDom())); + } + + return promises; +} + +void RTCRtpSender::GetCapabilities(const GlobalObject&, const nsAString& aKind, + Nullable<dom::RTCRtpCapabilities>& aResult) { + PeerConnectionImpl::GetCapabilities(aKind, aResult, sdp::Direction::kSend); +} + +void RTCRtpSender::WarnAboutBadSetParameters(const nsCString& aError) { + nsCString warning( + "WARNING! Invalid setParameters call detected! The good news? Firefox " + "supports sendEncodings in addTransceiver now, so we ask that you switch " + "over to using the parameters code you use for other browsers. Thank you " + "for your patience and support. The specific error was: "); + warning += aError; + mPc->SendWarningToConsole(warning); +} + +nsCString RTCRtpSender::GetEffectiveTLDPlus1() const { + return mPc->GetEffectiveTLDPlus1(); +} + +already_AddRefed<Promise> RTCRtpSender::SetParameters( + const dom::RTCRtpSendParameters& aParameters, ErrorResult& aError) { + dom::RTCRtpSendParameters paramsCopy(aParameters); + // When the setParameters method is called, the user agent MUST run the + // following steps: + // Let parameters be the method's first argument. + // Let sender be the RTCRtpSender object on which setParameters is invoked. + // Let transceiver be the RTCRtpTransceiver object associated with sender + // (i.e.sender is transceiver.[[Sender]]). + + RefPtr<dom::Promise> p = MakePromise(aError); + if (aError.Failed()) { + return nullptr; + } + + if (mPc->IsClosed()) { + p->MaybeRejectWithInvalidStateError("Peer connection is closed"); + return p.forget(); + } + + // If transceiver.[[Stopped]] is true, return a promise rejected with a newly + // created InvalidStateError. + if (mTransceiver->Stopped()) { + p->MaybeRejectWithInvalidStateError("This sender's transceiver is stopped"); + return p.forget(); + } + + // If sender.[[LastReturnedParameters]] is null, return a promise rejected + // with a newly created InvalidStateError. + if (!mLastReturnedParameters.isSome()) { + nsCString error( + "Cannot call setParameters without first calling getParameters"); + if (mAllowOldSetParameters) { + if (!mHaveWarnedBecauseNoGetParameters) { + mHaveWarnedBecauseNoGetParameters = true; + mozilla::glean::rtcrtpsender_setparameters::warn_no_getparameters + .AddToNumerator(1); +#ifdef EARLY_BETA_OR_EARLIER + mozilla::glean::rtcrtpsender_setparameters::blame_no_getparameters + .Get(GetEffectiveTLDPlus1()) + .Add(1); +#endif + } + WarnAboutBadSetParameters(error); + } else { + if (!mHaveFailedBecauseNoGetParameters) { + mHaveFailedBecauseNoGetParameters = true; + mozilla::glean::rtcrtpsender_setparameters::fail_no_getparameters + .AddToNumerator(1); + } + p->MaybeRejectWithInvalidStateError(error); + return p.forget(); + } + } + + // According to the spec, our consistency checking is based on + // [[LastReturnedParameters]], but if we're letting + // [[LastReturnedParameters]]==null slide, we still want to do + // consistency checking on _something_ so we can warn implementers if they + // are messing that up also. Just find something, _anything_, to do that + // checking with. + // TODO(bug 1803388): Remove this stuff once it is no longer needed. + // TODO(bug 1803389): Remove the glean errors once they are no longer needed. + Maybe<RTCRtpSendParameters> oldParams; + if (mAllowOldSetParameters) { + if (mLastReturnedParameters.isSome()) { + oldParams = mLastReturnedParameters; + } else if (mPendingParameters.isSome()) { + oldParams = mPendingParameters; + } else { + oldParams = Some(mParameters); + } + MOZ_ASSERT(oldParams.isSome()); + } else { + oldParams = mLastReturnedParameters; + } + MOZ_ASSERT(oldParams.isSome()); + + // Validate parameters by running the following steps: + // Let encodings be parameters.encodings. + // Let codecs be parameters.codecs. + // Let N be the number of RTCRtpEncodingParameters stored in + // sender.[[SendEncodings]]. + // If any of the following conditions are met, + // return a promise rejected with a newly created InvalidModificationError: + + bool pendingRidChangeFromCompatMode = false; + // encodings.length is different from N. + if (paramsCopy.mEncodings.Length() != oldParams->mEncodings.Length()) { + nsCString error("Cannot change the number of encodings with setParameters"); + if (!mAllowOldSetParameters) { + if (!mHaveFailedBecauseEncodingCountChange) { + mHaveFailedBecauseEncodingCountChange = true; + mozilla::glean::rtcrtpsender_setparameters::fail_length_changed + .AddToNumerator(1); + } + p->MaybeRejectWithInvalidModificationError(error); + return p.forget(); + } + // Make sure we don't use the old rids in SyncToJsep while we wait for the + // queued task below to update mParameters. + pendingRidChangeFromCompatMode = true; + mSimulcastEnvelopeSet = true; + if (!mHaveWarnedBecauseEncodingCountChange) { + mHaveWarnedBecauseEncodingCountChange = true; + mozilla::glean::rtcrtpsender_setparameters::warn_length_changed + .AddToNumerator(1); +#ifdef EARLY_BETA_OR_EARLIER + mozilla::glean::rtcrtpsender_setparameters::blame_length_changed + .Get(GetEffectiveTLDPlus1()) + .Add(1); +#endif + } + WarnAboutBadSetParameters(error); + } else { + // encodings has been re-ordered. + for (size_t i = 0; i < paramsCopy.mEncodings.Length(); ++i) { + const auto& oldEncoding = oldParams->mEncodings[i]; + const auto& newEncoding = paramsCopy.mEncodings[i]; + if (oldEncoding.mRid != newEncoding.mRid) { + nsCString error("Cannot change rid, or reorder encodings"); + if (!mHaveFailedBecauseRidChange) { + mHaveFailedBecauseRidChange = true; + mozilla::glean::rtcrtpsender_setparameters::fail_rid_changed + .AddToNumerator(1); + } + p->MaybeRejectWithInvalidModificationError(error); + return p.forget(); + } + } + } + + // TODO(bug 1803388): Handle this in webidl, once we stop allowing the old + // setParameters style. + if (!paramsCopy.mTransactionId.WasPassed()) { + nsCString error("transactionId is not set!"); + if (!mAllowOldSetParameters) { + if (!mHaveFailedBecauseNoTransactionId) { + mHaveFailedBecauseNoTransactionId = true; + mozilla::glean::rtcrtpsender_setparameters::fail_no_transactionid + .AddToNumerator(1); + } + p->MaybeRejectWithTypeError(error); + return p.forget(); + } + if (!mHaveWarnedBecauseNoTransactionId) { + mHaveWarnedBecauseNoTransactionId = true; + mozilla::glean::rtcrtpsender_setparameters::warn_no_transactionid + .AddToNumerator(1); +#ifdef EARLY_BETA_OR_EARLIER + mozilla::glean::rtcrtpsender_setparameters::blame_no_transactionid + .Get(GetEffectiveTLDPlus1()) + .Add(1); +#endif + } + WarnAboutBadSetParameters(error); + } else if (oldParams->mTransactionId != paramsCopy.mTransactionId) { + // Any parameter in parameters is marked as a Read-only parameter (such as + // RID) and has a value that is different from the corresponding parameter + // value in sender.[[LastReturnedParameters]]. Note that this also applies + // to transactionId. + nsCString error( + "Cannot change transaction id: call getParameters, modify the result, " + "and then call setParameters"); + if (!mAllowOldSetParameters) { + if (!mHaveFailedBecauseStaleTransactionId) { + mHaveFailedBecauseStaleTransactionId = true; + mozilla::glean::rtcrtpsender_setparameters::fail_stale_transactionid + .AddToNumerator(1); + } + p->MaybeRejectWithInvalidModificationError(error); + return p.forget(); + } + if (!mHaveWarnedBecauseStaleTransactionId) { + mHaveWarnedBecauseStaleTransactionId = true; + mozilla::glean::rtcrtpsender_setparameters::warn_stale_transactionid + .AddToNumerator(1); +#ifdef EARLY_BETA_OR_EARLIER + mozilla::glean::rtcrtpsender_setparameters::blame_stale_transactionid + .Get(GetEffectiveTLDPlus1()) + .Add(1); +#endif + } + WarnAboutBadSetParameters(error); + } + + // This could conceivably happen if we are allowing the old setParameters + // behavior. + if (!paramsCopy.mEncodings.Length()) { + nsCString error("Cannot set an empty encodings array"); + if (!mAllowOldSetParameters) { + if (!mHaveFailedBecauseNoEncodings) { + mHaveFailedBecauseNoEncodings = true; + mozilla::glean::rtcrtpsender_setparameters::fail_no_encodings + .AddToNumerator(1); + } + + p->MaybeRejectWithInvalidModificationError(error); + return p.forget(); + } + // TODO: Add some warning telemetry here + WarnAboutBadSetParameters(error); + // Just don't do this; it's stupid. + paramsCopy.mEncodings = oldParams->mEncodings; + } + + // TODO: Verify remaining read-only parameters + // headerExtensions (bug 1765851) + // rtcp (bug 1765852) + // codecs (bug 1534687) + + // CheckAndRectifyEncodings handles the following steps: + // If transceiver kind is "audio", remove the scaleResolutionDownBy member + // from all encodings that contain one. + // + // If transceiver kind is "video", and any encoding in encodings contains a + // scaleResolutionDownBy member whose value is less than 1.0, return a + // promise rejected with a newly created RangeError. + // + // Verify that each encoding in encodings has a maxFramerate member whose + // value is greater than or equal to 0.0. If one of the maxFramerate values + // does not meet this requirement, return a promise rejected with a newly + // created RangeError. + ErrorResult rv; + CheckAndRectifyEncodings(paramsCopy.mEncodings, mTransceiver->IsVideo(), rv); + if (rv.Failed()) { + if (!mHaveFailedBecauseOtherError) { + mHaveFailedBecauseOtherError = true; + mozilla::glean::rtcrtpsender_setparameters::fail_other.AddToNumerator(1); + } + p->MaybeReject(std::move(rv)); + return p.forget(); + } + + // If transceiver kind is "video", then for each encoding in encodings that + // doesn't contain a scaleResolutionDownBy member, add a + // scaleResolutionDownBy member with the value 1.0. + if (mTransceiver->IsVideo()) { + for (auto& encoding : paramsCopy.mEncodings) { + if (!encoding.mScaleResolutionDownBy.WasPassed()) { + encoding.mScaleResolutionDownBy.Construct(1.0); + } + } + } + + // Let p be a new promise. (see above) + + // In parallel, configure the media stack to use parameters to transmit + // sender.[[SenderTrack]]. + // Right now this is infallible. That may change someday. + + // We need to put this in a member variable, since MaybeUpdateConduit needs it + // This also allows PeerConnectionImpl to detect when there is a pending + // setParameters, which has implcations for the handling of + // setRemoteDescription. + mPendingRidChangeFromCompatMode = pendingRidChangeFromCompatMode; + mPendingParameters = Some(paramsCopy); + uint32_t serialNumber = ++mNumSetParametersCalls; + MaybeUpdateConduit(); + + // If the media stack is successfully configured with parameters, + // queue a task to run the following steps: + GetMainThreadSerialEventTarget()->Dispatch(NS_NewRunnableFunction( + __func__, + [this, self = RefPtr<RTCRtpSender>(this), p, paramsCopy, serialNumber] { + // Set sender.[[LastReturnedParameters]] to null. + mLastReturnedParameters = Nothing(); + // Set sender.[[SendEncodings]] to parameters.encodings. + mParameters = paramsCopy; + UpdateRestorableEncodings(mParameters.mEncodings); + // Only clear mPendingParameters if it matches; there could have been + // back-to-back calls to setParameters, and we only want to clear this + // if no subsequent setParameters is pending. + if (serialNumber == mNumSetParametersCalls) { + mPendingParameters = Nothing(); + // Ok, nothing has called SyncToJsep while this async task was + // pending. No need for special handling anymore. + mPendingRidChangeFromCompatMode = false; + } + MOZ_ASSERT(mParameters.mEncodings.Length()); + // Resolve p with undefined. + p->MaybeResolveWithUndefined(); + })); + + // Return p. + return p.forget(); +} + +// static +void RTCRtpSender::CheckAndRectifyEncodings( + Sequence<RTCRtpEncodingParameters>& aEncodings, bool aVideo, + ErrorResult& aRv) { + // If any encoding contains a rid member whose value does not conform to the + // grammar requirements specified in Section 10 of [RFC8851], throw a + // TypeError. + for (const auto& encoding : aEncodings) { + if (encoding.mRid.WasPassed()) { + std::string utf8Rid = NS_ConvertUTF16toUTF8(encoding.mRid.Value()).get(); + std::string error; + if (!SdpRidAttributeList::CheckRidValidity(utf8Rid, &error)) { + aRv.ThrowTypeError(nsCString(error)); + return; + } + if (utf8Rid.size() > SdpRidAttributeList::kMaxRidLength) { + std::ostringstream ss; + ss << "Rid can be at most " << SdpRidAttributeList::kMaxRidLength + << " characters long (due to internal limitations)"; + aRv.ThrowTypeError(nsCString(ss.str())); + return; + } + } + } + + if (aEncodings.Length() > 1) { + // If some but not all encodings contain a rid member, throw a TypeError. + // rid must be set if there is more than one encoding + // NOTE: Since rid is read-only, and the number of encodings cannot grow, + // this should never happen in setParameters. + for (const auto& encoding : aEncodings) { + if (!encoding.mRid.WasPassed()) { + aRv.ThrowTypeError("Missing rid"); + return; + } + } + + // If any encoding contains a rid member whose value is the same as that of + // a rid contained in another encoding in sendEncodings, throw a TypeError. + // NOTE: Since rid is read-only, and the number of encodings cannot grow, + // this should never happen in setParameters. + std::set<nsString> uniqueRids; + for (const auto& encoding : aEncodings) { + if (uniqueRids.count(encoding.mRid.Value())) { + aRv.ThrowTypeError("Duplicate rid"); + return; + } + uniqueRids.insert(encoding.mRid.Value()); + } + } + // TODO: ptime/adaptivePtime validation (bug 1733647) + + // If kind is "audio", remove the scaleResolutionDownBy member from all + // encodings that contain one. + if (!aVideo) { + for (auto& encoding : aEncodings) { + if (encoding.mScaleResolutionDownBy.WasPassed()) { + encoding.mScaleResolutionDownBy.Reset(); + } + if (encoding.mMaxFramerate.WasPassed()) { + encoding.mMaxFramerate.Reset(); + } + } + } + + // If any encoding contains a scaleResolutionDownBy member whose value is + // less than 1.0, throw a RangeError. + for (const auto& encoding : aEncodings) { + if (encoding.mScaleResolutionDownBy.WasPassed()) { + if (encoding.mScaleResolutionDownBy.Value() < 1.0f) { + aRv.ThrowRangeError("scaleResolutionDownBy must be >= 1.0"); + return; + } + } + } + + // Verify that the value of each maxFramerate member in sendEncodings that is + // defined is greater than 0.0. If one of the maxFramerate values does not + // meet this requirement, throw a RangeError. + for (const auto& encoding : aEncodings) { + if (encoding.mMaxFramerate.WasPassed()) { + if (encoding.mMaxFramerate.Value() < 0.0f) { + aRv.ThrowRangeError("maxFramerate must be non-negative"); + return; + } + } + } +} + +void RTCRtpSender::GetParameters(RTCRtpSendParameters& aParameters) { + MOZ_ASSERT(mParameters.mEncodings.Length()); + // If sender.[[LastReturnedParameters]] is not null, return + // sender.[[LastReturnedParameters]], and abort these steps. + if (mLastReturnedParameters.isSome()) { + aParameters = *mLastReturnedParameters; + return; + } + + // Let result be a new RTCRtpSendParameters dictionary constructed as follows: + + // transactionId is set to a new unique identifier + aParameters.mTransactionId.Construct(mPc->GenerateUUID()); + + // encodings is set to the value of the [[SendEncodings]] internal slot. + aParameters.mEncodings = mParameters.mEncodings; + + // The headerExtensions sequence is populated based on the header extensions + // that have been negotiated for sending + // TODO(bug 1765851): We do not support this yet + // aParameters.mHeaderExtensions.Construct(); + + // codecs is set to the value of the [[SendCodecs]] internal slot + // TODO(bug 1534687): We do not support this yet + + // rtcp.cname is set to the CNAME of the associated RTCPeerConnection. + // rtcp.reducedSize is set to true if reduced-size RTCP has been negotiated + // for sending, and false otherwise. + // TODO(bug 1765852): We do not support this yet + aParameters.mRtcp.Construct(); + aParameters.mRtcp.Value().mCname.Construct(); + aParameters.mRtcp.Value().mReducedSize.Construct(false); + aParameters.mHeaderExtensions.Construct(); + aParameters.mCodecs.Construct(); + + // Set sender.[[LastReturnedParameters]] to result. + mLastReturnedParameters = Some(aParameters); + + // Queue a task that sets sender.[[LastReturnedParameters]] to null. + GetMainThreadSerialEventTarget()->Dispatch(NS_NewRunnableFunction( + __func__, [this, self = RefPtr<RTCRtpSender>(this)] { + mLastReturnedParameters = Nothing(); + })); +} + +bool operator==(const RTCRtpEncodingParameters& a1, + const RTCRtpEncodingParameters& a2) { + // webidl does not generate types that are equality comparable + return a1.mActive == a2.mActive && a1.mFec == a2.mFec && + a1.mMaxBitrate == a2.mMaxBitrate && + a1.mMaxFramerate == a2.mMaxFramerate && a1.mPriority == a2.mPriority && + a1.mRid == a2.mRid && a1.mRtx == a2.mRtx && + a1.mScaleResolutionDownBy == a2.mScaleResolutionDownBy && + a1.mSsrc == a2.mSsrc; +} + +// static +void RTCRtpSender::ApplyJsEncodingToConduitEncoding( + const RTCRtpEncodingParameters& aJsEncoding, + VideoCodecConfig::Encoding* aConduitEncoding) { + aConduitEncoding->active = aJsEncoding.mActive; + if (aJsEncoding.mMaxBitrate.WasPassed()) { + aConduitEncoding->constraints.maxBr = aJsEncoding.mMaxBitrate.Value(); + } + if (aJsEncoding.mMaxFramerate.WasPassed()) { + aConduitEncoding->constraints.maxFps = + Some(aJsEncoding.mMaxFramerate.Value()); + } + if (aJsEncoding.mScaleResolutionDownBy.WasPassed()) { + // Optional does not have a valueOr, despite being based on Maybe + // :( + aConduitEncoding->constraints.scaleDownBy = + aJsEncoding.mScaleResolutionDownBy.Value(); + } else { + aConduitEncoding->constraints.scaleDownBy = 1.0f; + } +} + +void RTCRtpSender::UpdateRestorableEncodings( + const Sequence<RTCRtpEncodingParameters>& aEncodings) { + MOZ_ASSERT(aEncodings.Length()); + + if (GetJsepTransceiver().mSendTrack.GetNegotiatedDetails()) { + // Once initial negotiation completes, we are no longer allowed to restore + // the unicast encoding. + mUnicastEncoding.reset(); + } else if (mParameters.mEncodings.Length() == 1 && + !mParameters.mEncodings[0].mRid.WasPassed()) { + // If we have not completed the initial negotiation, and we currently are + // ridless unicast, we need to save our unicast encoding in case a + // rollback occurs. + mUnicastEncoding = Some(mParameters.mEncodings[0]); + } +} + +Sequence<RTCRtpEncodingParameters> RTCRtpSender::ToSendEncodings( + const std::vector<std::string>& aRids) const { + MOZ_ASSERT(!aRids.empty()); + + Sequence<RTCRtpEncodingParameters> result; + // If sendEncodings is given as input to this algorithm, and is non-empty, + // set the [[SendEncodings]] slot to sendEncodings. + for (const auto& rid : aRids) { + MOZ_ASSERT(!rid.empty()); + RTCRtpEncodingParameters encoding; + encoding.mActive = true; + encoding.mRid.Construct(NS_ConvertUTF8toUTF16(rid.c_str())); + Unused << result.AppendElement(encoding, fallible); + } + + // If sendEncodings is non-empty, set each encoding's scaleResolutionDownBy + // to 2^(length of sendEncodings - encoding index - 1). + if (mTransceiver->IsVideo()) { + double scale = 1.0f; + for (auto it = result.rbegin(); it != result.rend(); ++it) { + it->mScaleResolutionDownBy.Construct(scale); + scale *= 2; + } + } + + return result; +} + +void RTCRtpSender::MaybeGetJsepRids() { + MOZ_ASSERT(!mSimulcastEnvelopeSet); + MOZ_ASSERT(mParameters.mEncodings.Length()); + + auto jsepRids = GetJsepTransceiver().mSendTrack.GetRids(); + if (!jsepRids.empty()) { + UpdateRestorableEncodings(mParameters.mEncodings); + if (jsepRids.size() != 1 || !jsepRids[0].empty()) { + // JSEP is using at least one rid. Stomp our single ridless encoding + mParameters.mEncodings = ToSendEncodings(jsepRids); + } + mSimulcastEnvelopeSet = true; + mSimulcastEnvelopeSetByJSEP = true; + } +} + +Sequence<RTCRtpEncodingParameters> RTCRtpSender::GetMatchingEncodings( + const std::vector<std::string>& aRids) const { + Sequence<RTCRtpEncodingParameters> result; + + if (!aRids.empty() && !aRids[0].empty()) { + // Simulcast, or unicast with rid + for (const auto& encoding : mParameters.mEncodings) { + for (const auto& rid : aRids) { + auto utf16Rid = NS_ConvertUTF8toUTF16(rid.c_str()); + if (!encoding.mRid.WasPassed() || (utf16Rid == encoding.mRid.Value())) { + auto encodingCopy(encoding); + if (!encodingCopy.mRid.WasPassed()) { + encodingCopy.mRid.Construct(NS_ConvertUTF8toUTF16(rid.c_str())); + } + Unused << result.AppendElement(encodingCopy, fallible); + break; + } + } + } + } + + // If we're allowing the old setParameters behavior, we _might_ be able to + // get into this situation even if there were rids above. Be extra careful. + // Under normal circumstances, this just handles the ridless case. + if (!result.Length()) { + // Unicast with no specified rid. Restore mUnicastEncoding, if + // it exists, otherwise pick the first encoding. + if (mUnicastEncoding.isSome()) { + Unused << result.AppendElement(*mUnicastEncoding, fallible); + } else { + Unused << result.AppendElement(mParameters.mEncodings[0], fallible); + } + } + + return result; +} + +void RTCRtpSender::SetStreams( + const Sequence<OwningNonNull<DOMMediaStream>>& aStreams, ErrorResult& aRv) { + if (mPc->IsClosed()) { + aRv.ThrowInvalidStateError( + "Cannot call setStreams if the peer connection is closed"); + return; + } + + SetStreamsImpl(aStreams); + mPc->UpdateNegotiationNeeded(); +} + +void RTCRtpSender::SetStreamsImpl( + const Sequence<OwningNonNull<DOMMediaStream>>& aStreams) { + mStreams.Clear(); + std::set<nsString> ids; + for (const auto& stream : aStreams) { + nsString id; + stream->GetId(id); + if (!ids.count(id)) { + ids.insert(id); + mStreams.AppendElement(stream); + } + } +} + +void RTCRtpSender::GetStreams(nsTArray<RefPtr<DOMMediaStream>>& aStreams) { + aStreams = mStreams.Clone(); +} + +class ReplaceTrackOperation final : public PeerConnectionImpl::Operation { + public: + ReplaceTrackOperation(PeerConnectionImpl* aPc, + const RefPtr<RTCRtpTransceiver>& aTransceiver, + const RefPtr<MediaStreamTrack>& aTrack, + ErrorResult& aError); + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(ReplaceTrackOperation, + PeerConnectionImpl::Operation) + + private: + MOZ_CAN_RUN_SCRIPT + RefPtr<dom::Promise> CallImpl(ErrorResult& aError) override; + ~ReplaceTrackOperation() = default; + RefPtr<RTCRtpTransceiver> mTransceiver; + RefPtr<MediaStreamTrack> mNewTrack; +}; + +NS_IMPL_CYCLE_COLLECTION_INHERITED(ReplaceTrackOperation, + PeerConnectionImpl::Operation, mTransceiver, + mNewTrack) + +NS_IMPL_ADDREF_INHERITED(ReplaceTrackOperation, PeerConnectionImpl::Operation) +NS_IMPL_RELEASE_INHERITED(ReplaceTrackOperation, PeerConnectionImpl::Operation) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(ReplaceTrackOperation) +NS_INTERFACE_MAP_END_INHERITING(PeerConnectionImpl::Operation) + +ReplaceTrackOperation::ReplaceTrackOperation( + PeerConnectionImpl* aPc, const RefPtr<RTCRtpTransceiver>& aTransceiver, + const RefPtr<MediaStreamTrack>& aTrack, ErrorResult& aError) + : PeerConnectionImpl::Operation(aPc, aError), + mTransceiver(aTransceiver), + mNewTrack(aTrack) {} + +RefPtr<dom::Promise> ReplaceTrackOperation::CallImpl(ErrorResult& aError) { + RefPtr<RTCRtpSender> sender = mTransceiver->Sender(); + // If transceiver.[[Stopped]] is true, return a promise rejected with a newly + // created InvalidStateError. + if (mTransceiver->Stopped()) { + RefPtr<dom::Promise> error = sender->MakePromise(aError); + if (aError.Failed()) { + return nullptr; + } + MOZ_LOG(gSenderLog, LogLevel::Debug, + ("%s Cannot call replaceTrack when transceiver is stopped", + __FUNCTION__)); + error->MaybeRejectWithInvalidStateError( + "Cannot call replaceTrack when transceiver is stopped"); + return error; + } + + // Let p be a new promise. + RefPtr<dom::Promise> p = sender->MakePromise(aError); + if (aError.Failed()) { + return nullptr; + } + + if (!sender->SeamlessTrackSwitch(mNewTrack)) { + MOZ_LOG(gSenderLog, LogLevel::Info, + ("%s Could not seamlessly replace track", __FUNCTION__)); + p->MaybeRejectWithInvalidModificationError( + "Could not seamlessly replace track"); + return p; + } + + // Queue a task that runs the following steps: + GetMainThreadSerialEventTarget()->Dispatch(NS_NewRunnableFunction( + __func__, [p, sender, track = mNewTrack]() MOZ_CAN_RUN_SCRIPT_BOUNDARY { + // If connection.[[IsClosed]] is true, abort these steps. + // Set sender.[[SenderTrack]] to withTrack. + if (sender->SetSenderTrackWithClosedCheck(track)) { + // Resolve p with undefined. + p->MaybeResolveWithUndefined(); + } + })); + + // Return p. + return p; +} + +already_AddRefed<dom::Promise> RTCRtpSender::ReplaceTrack( + dom::MediaStreamTrack* aWithTrack, ErrorResult& aError) { + // If withTrack is non-null and withTrack.kind differs from the transceiver + // kind of transceiver, return a promise rejected with a newly created + // TypeError. + if (aWithTrack) { + nsString newKind; + aWithTrack->GetKind(newKind); + nsString oldKind; + mTransceiver->GetKind(oldKind); + if (newKind != oldKind) { + RefPtr<dom::Promise> error = MakePromise(aError); + if (aError.Failed()) { + return nullptr; + } + error->MaybeRejectWithTypeError( + "Cannot replaceTrack with a different kind!"); + return error.forget(); + } + } + + MOZ_LOG(gSenderLog, LogLevel::Debug, + ("%s[%s]: %s (%p to %p)", mPc->GetHandle().c_str(), GetMid().c_str(), + __FUNCTION__, mSenderTrack.get(), aWithTrack)); + + // Return the result of chaining the following steps to connection's + // operations chain: + RefPtr<PeerConnectionImpl::Operation> op = + new ReplaceTrackOperation(mPc, mTransceiver, aWithTrack, aError); + if (aError.Failed()) { + return nullptr; + } + // Static analysis forces us to use a temporary. + auto pc = mPc; + return pc->Chain(op, aError); +} + +nsPIDOMWindowInner* RTCRtpSender::GetParentObject() const { return mWindow; } + +already_AddRefed<dom::Promise> RTCRtpSender::MakePromise( + ErrorResult& aError) const { + return mPc->MakePromise(aError); +} + +bool RTCRtpSender::SeamlessTrackSwitch( + const RefPtr<MediaStreamTrack>& aWithTrack) { + // We do not actually update mSenderTrack here! Spec says that happens in a + // queued task after this is done (this happens in + // SetSenderTrackWithClosedCheck). + + mPipeline->SetTrack(aWithTrack); + + MaybeUpdateConduit(); + + // There may eventually be cases where a renegotiation is necessary to switch. + return true; +} + +void RTCRtpSender::SetTrack(const RefPtr<MediaStreamTrack>& aTrack) { + // Used for RTCPeerConnection.removeTrack and RTCPeerConnection.addTrack + mSenderTrack = aTrack; + SeamlessTrackSwitch(aTrack); + if (aTrack) { + // RFC says (in the section on remote rollback): + // However, an RtpTransceiver MUST NOT be removed if a track was attached + // to the RtpTransceiver via the addTrack method. + mAddTrackCalled = true; + } +} + +bool RTCRtpSender::SetSenderTrackWithClosedCheck( + const RefPtr<MediaStreamTrack>& aTrack) { + if (!mPc->IsClosed()) { + mSenderTrack = aTrack; + return true; + } + + return false; +} + +void RTCRtpSender::Shutdown() { + MOZ_ASSERT(NS_IsMainThread()); + mWatchManager.Shutdown(); + mPipeline->Shutdown(); + mPipeline = nullptr; +} + +void RTCRtpSender::BreakCycles() { + mWindow = nullptr; + mPc = nullptr; + mSenderTrack = nullptr; + mTransceiver = nullptr; + mStreams.Clear(); + mDtmf = nullptr; +} + +void RTCRtpSender::UpdateTransport() { + MOZ_ASSERT(NS_IsMainThread()); + if (!mHaveSetupTransport) { + mPipeline->SetLevel(GetJsepTransceiver().GetLevel()); + mHaveSetupTransport = true; + } + + mPipeline->UpdateTransport_m(GetJsepTransceiver().mTransport.mTransportId, + nullptr); +} + +void RTCRtpSender::MaybeUpdateConduit() { + // NOTE(pkerr) - the Call API requires the both local_ssrc and remote_ssrc be + // set to a non-zero value or the CreateVideo...Stream call will fail. + if (NS_WARN_IF(GetJsepTransceiver().mSendTrack.GetSsrcs().empty())) { + MOZ_ASSERT( + false, + "No local ssrcs! This is a bug in the jsep engine, and should never " + "happen!"); + return; + } + + if (!mPipeline) { + return; + } + + bool wasTransmitting = mTransmitting; + + if (mPipeline->mConduit->type() == MediaSessionConduit::VIDEO) { + Maybe<VideoConfig> newConfig = GetNewVideoConfig(); + if (newConfig.isSome()) { + ApplyVideoConfig(*newConfig); + } + } else { + Maybe<AudioConfig> newConfig = GetNewAudioConfig(); + if (newConfig.isSome()) { + ApplyAudioConfig(*newConfig); + } + } + + if (!mSenderTrack && !wasTransmitting && mTransmitting) { + MOZ_LOG(gSenderLog, LogLevel::Debug, + ("%s[%s]: %s Starting transmit conduit without send track!", + mPc->GetHandle().c_str(), GetMid().c_str(), __FUNCTION__)); + } +} + +void RTCRtpSender::SyncFromJsep(const JsepTransceiver& aJsepTransceiver) { + if (!mSimulcastEnvelopeSet) { + // JSEP is establishing the simulcast envelope for the first time, right now + // This is the addTrack (or addTransceiver without sendEncodings) case. + MaybeGetJsepRids(); + } else if (!aJsepTransceiver.mSendTrack.GetNegotiatedDetails() || + !aJsepTransceiver.mSendTrack.IsInHaveRemote()) { + // Spec says that we do not update our encodings until we're in stable, + // _unless_ this is the first negotiation. + std::vector<std::string> rids = aJsepTransceiver.mSendTrack.GetRids(); + if (mSimulcastEnvelopeSetByJSEP && rids.empty()) { + // JSEP previously set the simulcast envelope, but now it has no opinion + // regarding unicast/simulcast. This can only happen on rollback of the + // initial remote offer. + mParameters.mEncodings = GetMatchingEncodings(rids); + MOZ_ASSERT(mParameters.mEncodings.Length()); + mSimulcastEnvelopeSetByJSEP = false; + mSimulcastEnvelopeSet = false; + } else if (!rids.empty()) { + // JSEP has an opinion on the simulcast envelope, which trumps anything + // we have already. + mParameters.mEncodings = GetMatchingEncodings(rids); + MOZ_ASSERT(mParameters.mEncodings.Length()); + } + } + + MaybeUpdateConduit(); +} + +void RTCRtpSender::SyncToJsep(JsepTransceiver& aJsepTransceiver) const { + std::vector<std::string> streamIds; + for (const auto& stream : mStreams) { + nsString wideStreamId; + stream->GetId(wideStreamId); + std::string streamId = NS_ConvertUTF16toUTF8(wideStreamId).get(); + MOZ_ASSERT(!streamId.empty()); + streamIds.push_back(streamId); + } + + aJsepTransceiver.mSendTrack.UpdateStreamIds(streamIds); + + if (mSimulcastEnvelopeSet) { + std::vector<std::string> rids; + Maybe<RTCRtpSendParameters> parameters; + if (mPendingRidChangeFromCompatMode) { + // *sigh* If we have just let a setParameters change our rids, but we have + // not yet updated mParameters because the queued task hasn't run yet, + // we want to set the _new_ rids on the JsepTrack. So, we are forced to + // grab them from mPendingParameters. + parameters = mPendingParameters; + } else { + parameters = Some(mParameters); + } + for (const auto& encoding : parameters->mEncodings) { + if (encoding.mRid.WasPassed()) { + rids.push_back(NS_ConvertUTF16toUTF8(encoding.mRid.Value()).get()); + } else { + rids.push_back(""); + } + } + + aJsepTransceiver.mSendTrack.SetRids(rids); + } + + if (mTransceiver->IsVideo()) { + aJsepTransceiver.mSendTrack.SetMaxEncodings(webrtc::kMaxSimulcastStreams); + } else { + aJsepTransceiver.mSendTrack.SetMaxEncodings(1); + } + + if (mAddTrackCalled) { + aJsepTransceiver.SetOnlyExistsBecauseOfSetRemote(false); + } +} + +Maybe<RTCRtpSender::VideoConfig> RTCRtpSender::GetNewVideoConfig() { + // It is possible for SDP to signal that there is a send track, but there not + // actually be a send track, according to the specification; all that needs to + // happen is for the transceiver to be configured to send... + if (!GetJsepTransceiver().mSendTrack.GetNegotiatedDetails()) { + return Nothing(); + } + + VideoConfig oldConfig; + oldConfig.mSsrcs = mSsrcs; + oldConfig.mLocalRtpExtensions = mLocalRtpExtensions; + oldConfig.mCname = mCname; + oldConfig.mTransmitting = mTransmitting; + oldConfig.mVideoRtxSsrcs = mVideoRtxSsrcs; + oldConfig.mVideoCodec = mVideoCodec; + oldConfig.mVideoRtpRtcpConfig = mVideoRtpRtcpConfig; + oldConfig.mVideoCodecMode = mVideoCodecMode; + + VideoConfig newConfig(oldConfig); + + UpdateBaseConfig(&newConfig); + + newConfig.mVideoRtxSsrcs = GetJsepTransceiver().mSendTrack.GetRtxSsrcs(); + + const JsepTrackNegotiatedDetails details( + *GetJsepTransceiver().mSendTrack.GetNegotiatedDetails()); + + if (mSenderTrack) { + RefPtr<mozilla::dom::VideoStreamTrack> videotrack = + mSenderTrack->AsVideoStreamTrack(); + + if (!videotrack) { + MOZ_CRASH( + "In ConfigureVideoCodecMode, mSenderTrack is not video! This should " + "never happen!"); + } + + dom::MediaSourceEnum source = videotrack->GetSource().GetMediaSource(); + switch (source) { + case dom::MediaSourceEnum::Browser: + case dom::MediaSourceEnum::Screen: + case dom::MediaSourceEnum::Window: + case dom::MediaSourceEnum::Application: + newConfig.mVideoCodecMode = webrtc::VideoCodecMode::kScreensharing; + break; + + case dom::MediaSourceEnum::Camera: + case dom::MediaSourceEnum::Other: + // Other is used by canvas capture, which we treat as realtime video. + // This seems debatable, but we've been doing it this way for a long + // time, so this is likely fine. + newConfig.mVideoCodecMode = webrtc::VideoCodecMode::kRealtimeVideo; + break; + + case dom::MediaSourceEnum::Microphone: + case dom::MediaSourceEnum::AudioCapture: + case dom::MediaSourceEnum::EndGuard_: + MOZ_ASSERT(false); + break; + } + } + + std::vector<VideoCodecConfig> configs; + RTCRtpTransceiver::NegotiatedDetailsToVideoCodecConfigs(details, &configs); + + if (configs.empty()) { + // TODO: Are we supposed to plumb this error back to JS? This does not + // seem like a failure to set an answer, it just means that codec + // negotiation failed. For now, we're just doing the same thing we do + // if negotiation as a whole failed. + MOZ_LOG(gSenderLog, LogLevel::Error, + ("%s[%s]: %s No video codecs were negotiated (send).", + mPc->GetHandle().c_str(), GetMid().c_str(), __FUNCTION__)); + return Nothing(); + } + + newConfig.mVideoCodec = Some(configs[0]); + // Spec says that we start using new parameters right away, _before_ we + // update the parameters that are visible to JS (ie; mParameters). + const RTCRtpSendParameters& parameters = + mPendingParameters.isSome() ? *mPendingParameters : mParameters; + for (VideoCodecConfig::Encoding& conduitEncoding : + newConfig.mVideoCodec->mEncodings) { + for (const RTCRtpEncodingParameters& jsEncoding : parameters.mEncodings) { + std::string rid; + if (jsEncoding.mRid.WasPassed()) { + rid = NS_ConvertUTF16toUTF8(jsEncoding.mRid.Value()).get(); + } + if (conduitEncoding.rid == rid) { + ApplyJsEncodingToConduitEncoding(jsEncoding, &conduitEncoding); + break; + } + } + } + + newConfig.mVideoRtpRtcpConfig = Some(details.GetRtpRtcpConfig()); + + if (newConfig == oldConfig) { + MOZ_LOG(gSenderLog, LogLevel::Debug, + ("%s[%s]: %s No change in video config", mPc->GetHandle().c_str(), + GetMid().c_str(), __FUNCTION__)); + return Nothing(); + } + + if (newConfig.mVideoCodec.isSome()) { + MOZ_ASSERT(newConfig.mSsrcs.size() == + newConfig.mVideoCodec->mEncodings.size()); + } + return Some(newConfig); +} + +Maybe<RTCRtpSender::AudioConfig> RTCRtpSender::GetNewAudioConfig() { + AudioConfig oldConfig; + oldConfig.mSsrcs = mSsrcs; + oldConfig.mLocalRtpExtensions = mLocalRtpExtensions; + oldConfig.mCname = mCname; + oldConfig.mTransmitting = mTransmitting; + oldConfig.mAudioCodec = mAudioCodec; + + AudioConfig newConfig(oldConfig); + + UpdateBaseConfig(&newConfig); + + if (GetJsepTransceiver().mSendTrack.GetNegotiatedDetails() && + GetJsepTransceiver().mSendTrack.GetActive()) { + const auto& details( + *GetJsepTransceiver().mSendTrack.GetNegotiatedDetails()); + + std::vector<AudioCodecConfig> configs; + RTCRtpTransceiver::NegotiatedDetailsToAudioCodecConfigs(details, &configs); + if (configs.empty()) { + // TODO: Are we supposed to plumb this error back to JS? This does not + // seem like a failure to set an answer, it just means that codec + // negotiation failed. For now, we're just doing the same thing we do + // if negotiation as a whole failed. + MOZ_LOG(gSenderLog, LogLevel::Error, + ("%s[%s]: %s No audio codecs were negotiated (send)", + mPc->GetHandle().c_str(), GetMid().c_str(), __FUNCTION__)); + return Nothing(); + } + + std::vector<AudioCodecConfig> dtmfConfigs; + std::copy_if( + configs.begin(), configs.end(), std::back_inserter(dtmfConfigs), + [](const auto& value) { return value.mName == "telephone-event"; }); + + const AudioCodecConfig& sendCodec = configs[0]; + + if (!dtmfConfigs.empty()) { + // There is at least one telephone-event codec. + // We primarily choose the codec whose frequency matches the send codec. + // Secondarily we choose the one with the lowest frequency. + auto dtmfIterator = + std::find_if(dtmfConfigs.begin(), dtmfConfigs.end(), + [&sendCodec](const auto& dtmfCodec) { + return dtmfCodec.mFreq == sendCodec.mFreq; + }); + if (dtmfIterator == dtmfConfigs.end()) { + dtmfIterator = std::min_element( + dtmfConfigs.begin(), dtmfConfigs.end(), + [](const auto& a, const auto& b) { return a.mFreq < b.mFreq; }); + } + MOZ_ASSERT(dtmfIterator != dtmfConfigs.end()); + newConfig.mDtmfPt = dtmfIterator->mType; + newConfig.mDtmfFreq = dtmfIterator->mFreq; + } + + newConfig.mAudioCodec = Some(sendCodec); + } + + if (newConfig == oldConfig) { + MOZ_LOG(gSenderLog, LogLevel::Debug, + ("%s[%s]: %s No change in audio config", mPc->GetHandle().c_str(), + GetMid().c_str(), __FUNCTION__)); + return Nothing(); + } + + return Some(newConfig); +} + +void RTCRtpSender::UpdateBaseConfig(BaseConfig* aConfig) { + aConfig->mSsrcs = GetJsepTransceiver().mSendTrack.GetSsrcs(); + aConfig->mCname = GetJsepTransceiver().mSendTrack.GetCNAME(); + + if (GetJsepTransceiver().mSendTrack.GetNegotiatedDetails() && + GetJsepTransceiver().mSendTrack.GetActive()) { + const auto& details( + *GetJsepTransceiver().mSendTrack.GetNegotiatedDetails()); + { + std::vector<webrtc::RtpExtension> extmaps; + // @@NG read extmap from track + details.ForEachRTPHeaderExtension( + [&extmaps](const SdpExtmapAttributeList::Extmap& extmap) { + extmaps.emplace_back(extmap.extensionname, extmap.entry); + }); + aConfig->mLocalRtpExtensions = extmaps; + } + } + // RTCRtpTransceiver::IsSending is updated after negotiation completes, in a + // queued task (which we may be in right now). Don't use + // JsepTrack::GetActive, because that updates before the queued task, which + // is too early for some of the things we interact with here (eg; + // RTCDTMFSender). + aConfig->mTransmitting = mTransceiver->IsSending(); +} + +void RTCRtpSender::ApplyVideoConfig(const VideoConfig& aConfig) { + if (aConfig.mVideoCodec.isSome()) { + MOZ_ASSERT(aConfig.mSsrcs.size() == aConfig.mVideoCodec->mEncodings.size()); + } + + mSsrcs = aConfig.mSsrcs; + mCname = aConfig.mCname; + mLocalRtpExtensions = aConfig.mLocalRtpExtensions; + + mVideoRtxSsrcs = aConfig.mVideoRtxSsrcs; + mVideoCodec = aConfig.mVideoCodec; + mVideoRtpRtcpConfig = aConfig.mVideoRtpRtcpConfig; + mVideoCodecMode = aConfig.mVideoCodecMode; + + mTransmitting = aConfig.mTransmitting; +} + +void RTCRtpSender::ApplyAudioConfig(const AudioConfig& aConfig) { + mTransmitting = false; + + mSsrcs = aConfig.mSsrcs; + mCname = aConfig.mCname; + mLocalRtpExtensions = aConfig.mLocalRtpExtensions; + + mAudioCodec = aConfig.mAudioCodec; + + if (aConfig.mDtmfPt >= 0) { + mDtmf->SetPayloadType(aConfig.mDtmfPt, aConfig.mDtmfFreq); + } + + mTransmitting = aConfig.mTransmitting; +} + +void RTCRtpSender::Stop() { + MOZ_ASSERT(mTransceiver->Stopped()); + mTransmitting = false; +} + +bool RTCRtpSender::HasTrack(const dom::MediaStreamTrack* aTrack) const { + if (!mSenderTrack) { + return false; + } + + if (!aTrack) { + return true; + } + + return mSenderTrack.get() == aTrack; +} + +RefPtr<MediaPipelineTransmit> RTCRtpSender::GetPipeline() const { + return mPipeline; +} + +std::string RTCRtpSender::GetMid() const { return mTransceiver->GetMidAscii(); } + +JsepTransceiver& RTCRtpSender::GetJsepTransceiver() { + return mTransceiver->GetJsepTransceiver(); +} + +void RTCRtpSender::UpdateDtmfSender() { + if (!mDtmf) { + return; + } + + if (mTransmitting) { + return; + } + + mDtmf->StopPlayout(); +} + +} // namespace mozilla::dom + +#undef LOGTAG diff --git a/dom/media/webrtc/jsapi/RTCRtpSender.h b/dom/media/webrtc/jsapi/RTCRtpSender.h new file mode 100644 index 0000000000..0c1282e0db --- /dev/null +++ b/dom/media/webrtc/jsapi/RTCRtpSender.h @@ -0,0 +1,260 @@ +/* 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/. */ + +#ifndef _RTCRtpSender_h_ +#define _RTCRtpSender_h_ + +#include "nsISupports.h" +#include "nsWrapperCache.h" +#include "mozilla/RefPtr.h" +#include "mozilla/StateMirroring.h" +#include "mozilla/Maybe.h" +#include "js/RootingAPI.h" +#include "libwebrtcglue/RtpRtcpConfig.h" +#include "nsTArray.h" +#include "mozilla/dom/RTCStatsReportBinding.h" +#include "mozilla/dom/RTCRtpCapabilitiesBinding.h" +#include "mozilla/dom/RTCRtpParametersBinding.h" +#include "RTCStatsReport.h" +#include "jsep/JsepTrack.h" +#include "transportbridge/MediaPipeline.h" + +class nsPIDOMWindowInner; + +namespace mozilla { +class MediaSessionConduit; +class MediaTransportHandler; +class JsepTransceiver; +class PeerConnectionImpl; +class DOMMediaStream; + +namespace dom { +class MediaStreamTrack; +class Promise; +class RTCDtlsTransport; +class RTCDTMFSender; +struct RTCRtpCapabilities; +class RTCRtpTransceiver; + +class RTCRtpSender : public nsISupports, + public nsWrapperCache, + public MediaPipelineTransmitControlInterface { + public: + RTCRtpSender(nsPIDOMWindowInner* aWindow, PeerConnectionImpl* aPc, + MediaTransportHandler* aTransportHandler, + AbstractThread* aCallThread, nsISerialEventTarget* aStsThread, + MediaSessionConduit* aConduit, dom::MediaStreamTrack* aTrack, + const Sequence<RTCRtpEncodingParameters>& aEncodings, + RTCRtpTransceiver* aTransceiver); + + // nsISupports + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + NS_DECL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(RTCRtpSender) + + JSObject* WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) override; + + // webidl + MediaStreamTrack* GetTrack() const { return mSenderTrack; } + RTCDtlsTransport* GetTransport() const; + RTCDTMFSender* GetDtmf() const; + MOZ_CAN_RUN_SCRIPT + already_AddRefed<Promise> ReplaceTrack(MediaStreamTrack* aWithTrack, + ErrorResult& aError); + already_AddRefed<Promise> GetStats(ErrorResult& aError); + static void GetCapabilities(const GlobalObject&, const nsAString& kind, + Nullable<dom::RTCRtpCapabilities>& result); + already_AddRefed<Promise> SetParameters( + const dom::RTCRtpSendParameters& aParameters, ErrorResult& aError); + // Not a simple getter, so not const + // See https://w3c.github.io/webrtc-pc/#dom-rtcrtpsender-getparameters + void GetParameters(RTCRtpSendParameters& aParameters); + + static void CheckAndRectifyEncodings( + Sequence<RTCRtpEncodingParameters>& aEncodings, bool aVideo, + ErrorResult& aRv); + + nsPIDOMWindowInner* GetParentObject() const; + nsTArray<RefPtr<RTCStatsPromise>> GetStatsInternal( + bool aSkipIceStats = false); + + void SetStreams(const Sequence<OwningNonNull<DOMMediaStream>>& aStreams, + ErrorResult& aRv); + // ChromeOnly webidl + void GetStreams(nsTArray<RefPtr<DOMMediaStream>>& aStreams); + // ChromeOnly webidl + void SetStreamsImpl(const Sequence<OwningNonNull<DOMMediaStream>>& aStreams); + // ChromeOnly webidl + void SetTrack(const RefPtr<MediaStreamTrack>& aTrack); + void Shutdown(); + void BreakCycles(); + // Terminal state, reached through stopping RTCRtpTransceiver. + void Stop(); + bool HasTrack(const dom::MediaStreamTrack* aTrack) const; + bool IsMyPc(const PeerConnectionImpl* aPc) const { return mPc.get() == aPc; } + RefPtr<MediaPipelineTransmit> GetPipeline() const; + already_AddRefed<dom::Promise> MakePromise(ErrorResult& aError) const; + bool SeamlessTrackSwitch(const RefPtr<MediaStreamTrack>& aWithTrack); + bool SetSenderTrackWithClosedCheck(const RefPtr<MediaStreamTrack>& aTrack); + + // This is called when we set an answer (ie; when the transport is finalized). + void UpdateTransport(); + void SyncToJsep(JsepTransceiver& aJsepTransceiver) const; + void SyncFromJsep(const JsepTransceiver& aJsepTransceiver); + void MaybeUpdateConduit(); + + AbstractCanonical<Ssrcs>* CanonicalSsrcs() { return &mSsrcs; } + AbstractCanonical<Ssrcs>* CanonicalVideoRtxSsrcs() { return &mVideoRtxSsrcs; } + AbstractCanonical<RtpExtList>* CanonicalLocalRtpExtensions() { + return &mLocalRtpExtensions; + } + + AbstractCanonical<Maybe<AudioCodecConfig>>* CanonicalAudioCodec() { + return &mAudioCodec; + } + + AbstractCanonical<Maybe<VideoCodecConfig>>* CanonicalVideoCodec() { + return &mVideoCodec; + } + AbstractCanonical<Maybe<RtpRtcpConfig>>* CanonicalVideoRtpRtcpConfig() { + return &mVideoRtpRtcpConfig; + } + AbstractCanonical<webrtc::VideoCodecMode>* CanonicalVideoCodecMode() { + return &mVideoCodecMode; + } + AbstractCanonical<std::string>* CanonicalCname() { return &mCname; } + AbstractCanonical<bool>* CanonicalTransmitting() override { + return &mTransmitting; + } + + bool HasPendingSetParameters() const { return mPendingParameters.isSome(); } + void InvalidateLastReturnedParameters() { + mLastReturnedParameters = Nothing(); + } + + private: + virtual ~RTCRtpSender(); + + std::string GetMid() const; + JsepTransceiver& GetJsepTransceiver(); + static void ApplyJsEncodingToConduitEncoding( + const RTCRtpEncodingParameters& aJsEncoding, + VideoCodecConfig::Encoding* aConduitEncoding); + void UpdateRestorableEncodings( + const Sequence<RTCRtpEncodingParameters>& aEncodings); + Sequence<RTCRtpEncodingParameters> GetMatchingEncodings( + const std::vector<std::string>& aRids) const; + Sequence<RTCRtpEncodingParameters> ToSendEncodings( + const std::vector<std::string>& aRids) const; + void MaybeGetJsepRids(); + void UpdateDtmfSender(); + + void WarnAboutBadSetParameters(const nsCString& aError); + nsCString GetEffectiveTLDPlus1() const; + + WatchManager<RTCRtpSender> mWatchManager; + nsCOMPtr<nsPIDOMWindowInner> mWindow; + RefPtr<PeerConnectionImpl> mPc; + RefPtr<dom::MediaStreamTrack> mSenderTrack; + bool mAddTrackCalled = false; + RTCRtpSendParameters mParameters; + Maybe<RTCRtpSendParameters> mPendingParameters; + uint32_t mNumSetParametersCalls = 0; + // When JSEP goes from simulcast to unicast without a rid, and we started out + // as unicast without a rid, we are supposed to restore that unicast encoding + // from before. + Maybe<RTCRtpEncodingParameters> mUnicastEncoding; + bool mSimulcastEnvelopeSet = false; + bool mSimulcastEnvelopeSetByJSEP = false; + bool mPendingRidChangeFromCompatMode = false; + Maybe<RTCRtpSendParameters> mLastReturnedParameters; + RefPtr<MediaPipelineTransmit> mPipeline; + RefPtr<MediaTransportHandler> mTransportHandler; + RefPtr<RTCRtpTransceiver> mTransceiver; + nsTArray<RefPtr<DOMMediaStream>> mStreams; + bool mHaveSetupTransport = false; + // TODO(bug 1803388): Remove this stuff once it is no longer needed. + bool mAllowOldSetParameters = false; + + // TODO(bug 1803388): Remove the glean warnings once they are no longer needed + bool mHaveWarnedBecauseNoGetParameters = false; + bool mHaveWarnedBecauseEncodingCountChange = false; + bool mHaveWarnedBecauseNoTransactionId = false; + bool mHaveWarnedBecauseStaleTransactionId = false; + // TODO(bug 1803389): Remove the glean errors once they are no longer needed. + bool mHaveFailedBecauseNoGetParameters = false; + bool mHaveFailedBecauseEncodingCountChange = false; + bool mHaveFailedBecauseRidChange = false; + bool mHaveFailedBecauseNoTransactionId = false; + bool mHaveFailedBecauseStaleTransactionId = false; + bool mHaveFailedBecauseNoEncodings = false; + bool mHaveFailedBecauseOtherError = false; + + RefPtr<dom::RTCDTMFSender> mDtmf; + + class BaseConfig { + public: + // TODO(bug 1744116): Use = default here + bool operator==(const BaseConfig& aOther) const { + return mSsrcs == aOther.mSsrcs && + mLocalRtpExtensions == aOther.mLocalRtpExtensions && + mCname == aOther.mCname && mTransmitting == aOther.mTransmitting; + } + Ssrcs mSsrcs; + RtpExtList mLocalRtpExtensions; + std::string mCname; + bool mTransmitting = false; + }; + + class VideoConfig : public BaseConfig { + public: + // TODO(bug 1744116): Use = default here + bool operator==(const VideoConfig& aOther) const { + return BaseConfig::operator==(aOther) && + mVideoRtxSsrcs == aOther.mVideoRtxSsrcs && + mVideoCodec == aOther.mVideoCodec && + mVideoRtpRtcpConfig == aOther.mVideoRtpRtcpConfig && + mVideoCodecMode == aOther.mVideoCodecMode; + } + Ssrcs mVideoRtxSsrcs; + Maybe<VideoCodecConfig> mVideoCodec; + Maybe<RtpRtcpConfig> mVideoRtpRtcpConfig; + webrtc::VideoCodecMode mVideoCodecMode = + webrtc::VideoCodecMode::kRealtimeVideo; + }; + + class AudioConfig : public BaseConfig { + public: + // TODO(bug 1744116): Use = default here + bool operator==(const AudioConfig& aOther) const { + return BaseConfig::operator==(aOther) && + mAudioCodec == aOther.mAudioCodec && mDtmfPt == aOther.mDtmfPt && + mDtmfFreq == aOther.mDtmfFreq; + } + Maybe<AudioCodecConfig> mAudioCodec; + int32_t mDtmfPt = -1; + int32_t mDtmfFreq = 0; + }; + + Maybe<VideoConfig> GetNewVideoConfig(); + Maybe<AudioConfig> GetNewAudioConfig(); + void UpdateBaseConfig(BaseConfig* aConfig); + void ApplyVideoConfig(const VideoConfig& aConfig); + void ApplyAudioConfig(const AudioConfig& aConfig); + + Canonical<Ssrcs> mSsrcs; + Canonical<Ssrcs> mVideoRtxSsrcs; + Canonical<RtpExtList> mLocalRtpExtensions; + + Canonical<Maybe<AudioCodecConfig>> mAudioCodec; + Canonical<Maybe<VideoCodecConfig>> mVideoCodec; + Canonical<Maybe<RtpRtcpConfig>> mVideoRtpRtcpConfig; + Canonical<webrtc::VideoCodecMode> mVideoCodecMode; + Canonical<std::string> mCname; + Canonical<bool> mTransmitting; +}; + +} // namespace dom +} // namespace mozilla +#endif // _RTCRtpSender_h_ diff --git a/dom/media/webrtc/jsapi/RTCRtpTransceiver.cpp b/dom/media/webrtc/jsapi/RTCRtpTransceiver.cpp new file mode 100644 index 0000000000..bf4f74dd5d --- /dev/null +++ b/dom/media/webrtc/jsapi/RTCRtpTransceiver.cpp @@ -0,0 +1,1080 @@ +/* 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 "jsapi/RTCRtpTransceiver.h" +#include "mozilla/UniquePtr.h" +#include <algorithm> +#include <string> +#include <vector> +#include "libwebrtcglue/AudioConduit.h" +#include "libwebrtcglue/VideoConduit.h" +#include "MediaTrackGraph.h" +#include "transportbridge/MediaPipeline.h" +#include "transportbridge/MediaPipelineFilter.h" +#include "jsep/JsepTrack.h" +#include "sdp/SdpHelper.h" +#include "MediaTrackGraphImpl.h" +#include "transport/logging.h" +#include "MediaEngine.h" +#include "nsIPrincipal.h" +#include "MediaSegment.h" +#include "RemoteTrackSource.h" +#include "libwebrtcglue/RtpRtcpConfig.h" +#include "MediaTransportHandler.h" +#include "mozilla/dom/RTCRtpReceiverBinding.h" +#include "mozilla/dom/RTCRtpSenderBinding.h" +#include "mozilla/dom/RTCRtpTransceiverBinding.h" +#include "mozilla/dom/Promise.h" +#include "RTCDtlsTransport.h" +#include "RTCRtpReceiver.h" +#include "RTCRtpSender.h" +#include "RTCDTMFSender.h" +#include "systemservices/MediaUtils.h" +#include "libwebrtcglue/WebrtcCallWrapper.h" +#include "libwebrtcglue/WebrtcGmpVideoCodec.h" +#include "utils/PerformanceRecorder.h" + +namespace mozilla { + +using namespace dom; + +namespace { +struct ConduitControlState : public AudioConduitControlInterface, + public VideoConduitControlInterface { + ConduitControlState(RTCRtpTransceiver* aTransceiver, RTCRtpSender* aSender, + RTCRtpReceiver* aReceiver) + : mTransceiver(new nsMainThreadPtrHolder<RTCRtpTransceiver>( + "ConduitControlState::mTransceiver", aTransceiver, false)), + mSender(new nsMainThreadPtrHolder<dom::RTCRtpSender>( + "ConduitControlState::mSender", aSender, false)), + mReceiver(new nsMainThreadPtrHolder<dom::RTCRtpReceiver>( + "ConduitControlState::mReceiver", aReceiver, false)) {} + + const nsMainThreadPtrHandle<RTCRtpTransceiver> mTransceiver; + const nsMainThreadPtrHandle<RTCRtpSender> mSender; + const nsMainThreadPtrHandle<RTCRtpReceiver> mReceiver; + + // MediaConduitControlInterface + AbstractCanonical<bool>* CanonicalReceiving() override { + return mReceiver->CanonicalReceiving(); + } + AbstractCanonical<bool>* CanonicalTransmitting() override { + return mSender->CanonicalTransmitting(); + } + AbstractCanonical<Ssrcs>* CanonicalLocalSsrcs() override { + return mSender->CanonicalSsrcs(); + } + AbstractCanonical<std::string>* CanonicalLocalCname() override { + return mSender->CanonicalCname(); + } + AbstractCanonical<std::string>* CanonicalMid() override { + return mTransceiver->CanonicalMid(); + } + AbstractCanonical<Ssrc>* CanonicalRemoteSsrc() override { + return mReceiver->CanonicalSsrc(); + } + AbstractCanonical<std::string>* CanonicalSyncGroup() override { + return mTransceiver->CanonicalSyncGroup(); + } + AbstractCanonical<RtpExtList>* CanonicalLocalRecvRtpExtensions() override { + return mReceiver->CanonicalLocalRtpExtensions(); + } + AbstractCanonical<RtpExtList>* CanonicalLocalSendRtpExtensions() override { + return mSender->CanonicalLocalRtpExtensions(); + } + + // AudioConduitControlInterface + AbstractCanonical<Maybe<AudioCodecConfig>>* CanonicalAudioSendCodec() + override { + return mSender->CanonicalAudioCodec(); + } + AbstractCanonical<std::vector<AudioCodecConfig>>* CanonicalAudioRecvCodecs() + override { + return mReceiver->CanonicalAudioCodecs(); + } + MediaEventSource<DtmfEvent>& OnDtmfEvent() override { + return mSender->GetDtmf()->OnDtmfEvent(); + } + + // VideoConduitControlInterface + AbstractCanonical<Ssrcs>* CanonicalLocalVideoRtxSsrcs() override { + return mSender->CanonicalVideoRtxSsrcs(); + } + AbstractCanonical<Ssrc>* CanonicalRemoteVideoRtxSsrc() override { + return mReceiver->CanonicalVideoRtxSsrc(); + } + AbstractCanonical<Maybe<VideoCodecConfig>>* CanonicalVideoSendCodec() + override { + return mSender->CanonicalVideoCodec(); + } + AbstractCanonical<Maybe<RtpRtcpConfig>>* CanonicalVideoSendRtpRtcpConfig() + override { + return mSender->CanonicalVideoRtpRtcpConfig(); + } + AbstractCanonical<std::vector<VideoCodecConfig>>* CanonicalVideoRecvCodecs() + override { + return mReceiver->CanonicalVideoCodecs(); + } + AbstractCanonical<Maybe<RtpRtcpConfig>>* CanonicalVideoRecvRtpRtcpConfig() + override { + return mReceiver->CanonicalVideoRtpRtcpConfig(); + } + AbstractCanonical<webrtc::VideoCodecMode>* CanonicalVideoCodecMode() + override { + return mSender->CanonicalVideoCodecMode(); + } +}; +} // namespace + +MOZ_MTLOG_MODULE("RTCRtpTransceiver") + +NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(RTCRtpTransceiver) +NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(RTCRtpTransceiver) + if (tmp->mHandlingUnlink) { + tmp->BreakCycles(); + tmp->mHandlingUnlink = false; + } + NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER +NS_IMPL_CYCLE_COLLECTION_UNLINK_END +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(RTCRtpTransceiver) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mWindow, mPc, mSendTrack, mReceiver, + mSender, mDtlsTransport, + mLastStableDtlsTransport) +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END + +NS_IMPL_CYCLE_COLLECTING_ADDREF(RTCRtpTransceiver) +NS_IMPL_CYCLE_COLLECTING_RELEASE(RTCRtpTransceiver) +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(RTCRtpTransceiver) + NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY + NS_INTERFACE_MAP_ENTRY(nsISupports) +NS_INTERFACE_MAP_END + +#define INIT_CANONICAL(name, val) \ + name(AbstractThread::MainThread(), val, \ + "RTCRtpTransceiver::" #name " (Canonical)") + +RTCRtpTransceiver::RTCRtpTransceiver( + nsPIDOMWindowInner* aWindow, bool aPrivacyNeeded, PeerConnectionImpl* aPc, + MediaTransportHandler* aTransportHandler, JsepSession* aJsepSession, + const std::string& aTransceiverId, bool aIsVideo, + nsISerialEventTarget* aStsThread, dom::MediaStreamTrack* aSendTrack, + WebrtcCallWrapper* aCallWrapper, RTCStatsIdGenerator* aIdGenerator) + : mWindow(aWindow), + mPc(aPc), + mTransportHandler(aTransportHandler), + mTransceiverId(aTransceiverId), + mJsepTransceiver(*aJsepSession->GetTransceiver(mTransceiverId)), + mStsThread(aStsThread), + mCallWrapper(aCallWrapper), + mSendTrack(aSendTrack), + mIdGenerator(aIdGenerator), + mPrincipalPrivacy(aPrivacyNeeded ? PrincipalPrivacy::Private + : PrincipalPrivacy::NonPrivate), + mIsVideo(aIsVideo), + INIT_CANONICAL(mMid, std::string()), + INIT_CANONICAL(mSyncGroup, std::string()) {} + +#undef INIT_CANONICAL + +RTCRtpTransceiver::~RTCRtpTransceiver() = default; + +SdpDirectionAttribute::Direction ToSdpDirection( + RTCRtpTransceiverDirection aDirection) { + switch (aDirection) { + case dom::RTCRtpTransceiverDirection::Sendrecv: + return SdpDirectionAttribute::Direction::kSendrecv; + case dom::RTCRtpTransceiverDirection::Sendonly: + return SdpDirectionAttribute::Direction::kSendonly; + case dom::RTCRtpTransceiverDirection::Recvonly: + return SdpDirectionAttribute::Direction::kRecvonly; + case dom::RTCRtpTransceiverDirection::Inactive: + return SdpDirectionAttribute::Direction::kInactive; + case dom::RTCRtpTransceiverDirection::EndGuard_:; + } + MOZ_CRASH("Invalid transceiver direction!"); +} + +static uint32_t sRemoteSourceId = 0; + +// TODO(bug 1401592): Once we implement the sendEncodings stuff, there will +// need to be validation code in here. +void RTCRtpTransceiver::Init(const RTCRtpTransceiverInit& aInit, + ErrorResult& aRv) { + TrackingId trackingId(TrackingId::Source::RTCRtpReceiver, sRemoteSourceId++, + TrackingId::TrackAcrossProcesses::Yes); + if (IsVideo()) { + InitVideo(trackingId); + } else { + InitAudio(); + } + + if (!IsValid()) { + aRv = NS_ERROR_UNEXPECTED; + return; + } + + mReceiver = new RTCRtpReceiver(mWindow, mPrincipalPrivacy, mPc, + mTransportHandler, mCallWrapper->mCallThread, + mStsThread, mConduit, this, trackingId); + + mSender = new RTCRtpSender(mWindow, mPc, mTransportHandler, + mCallWrapper->mCallThread, mStsThread, mConduit, + mSendTrack, aInit.mSendEncodings, this); + + if (mConduit) { + InitConduitControl(); + } + + mSender->SetStreamsImpl(aInit.mStreams); + mDirection = aInit.mDirection; +} + +void RTCRtpTransceiver::SetDtlsTransport(dom::RTCDtlsTransport* aDtlsTransport, + bool aStable) { + mDtlsTransport = aDtlsTransport; + if (aStable) { + mLastStableDtlsTransport = mDtlsTransport; + } +} + +void RTCRtpTransceiver::RollbackToStableDtlsTransport() { + mDtlsTransport = mLastStableDtlsTransport; +} + +void RTCRtpTransceiver::InitAudio() { + mConduit = AudioSessionConduit::Create(mCallWrapper, mStsThread); + + if (!mConduit) { + MOZ_MTLOG(ML_ERROR, mPc->GetHandle() + << "[" << mMid.Ref() << "]: " << __FUNCTION__ + << ": Failed to create AudioSessionConduit"); + // TODO(bug 1422897): We need a way to record this when it happens in the + // wild. + } +} + +void RTCRtpTransceiver::InitVideo(const TrackingId& aRecvTrackingId) { + VideoSessionConduit::Options options; + options.mVideoLatencyTestEnable = + Preferences::GetBool("media.video.test_latency", false); + options.mMinBitrate = std::max( + 0, + Preferences::GetInt("media.peerconnection.video.min_bitrate", 0) * 1000); + options.mStartBitrate = std::max( + 0, Preferences::GetInt("media.peerconnection.video.start_bitrate", 0) * + 1000); + options.mPrefMaxBitrate = std::max( + 0, + Preferences::GetInt("media.peerconnection.video.max_bitrate", 0) * 1000); + if (options.mMinBitrate != 0 && + options.mMinBitrate < kViEMinCodecBitrate_bps) { + options.mMinBitrate = kViEMinCodecBitrate_bps; + } + if (options.mStartBitrate < options.mMinBitrate) { + options.mStartBitrate = options.mMinBitrate; + } + if (options.mPrefMaxBitrate && + options.mStartBitrate > options.mPrefMaxBitrate) { + options.mStartBitrate = options.mPrefMaxBitrate; + } + // XXX We'd love if this was a live param for testing adaptation/etc + // in automation + options.mMinBitrateEstimate = + std::max(0, Preferences::GetInt( + "media.peerconnection.video.min_bitrate_estimate", 0) * + 1000); + options.mSpatialLayers = std::max( + 1, Preferences::GetInt("media.peerconnection.video.svc.spatial", 0)); + options.mTemporalLayers = std::max( + 1, Preferences::GetInt("media.peerconnection.video.svc.temporal", 0)); + options.mDenoising = + Preferences::GetBool("media.peerconnection.video.denoising", false); + options.mLockScaling = + Preferences::GetBool("media.peerconnection.video.lock_scaling", false); + + mConduit = + VideoSessionConduit::Create(mCallWrapper, mStsThread, std::move(options), + mPc->GetHandle(), aRecvTrackingId); + + if (!mConduit) { + MOZ_MTLOG(ML_ERROR, mPc->GetHandle() + << "[" << mMid.Ref() << "]: " << __FUNCTION__ + << ": Failed to create VideoSessionConduit"); + // TODO(bug 1422897): We need a way to record this when it happens in the + // wild. + } +} + +void RTCRtpTransceiver::InitConduitControl() { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(mConduit); + ConduitControlState control(this, mSender, mReceiver); + mCallWrapper->mCallThread->Dispatch(NS_NewRunnableFunction( + __func__, [conduit = mConduit, control = std::move(control)]() mutable { + conduit->AsVideoSessionConduit().apply( + [&](VideoSessionConduit* aConduit) { + aConduit->InitControl(&control); + }); + conduit->AsAudioSessionConduit().apply( + [&](AudioSessionConduit* aConduit) { + aConduit->InitControl(&control); + }); + })); +} + +void RTCRtpTransceiver::Close() { + // Called via PCImpl::Close -> PCImpl::CloseInt -> PCImpl::ShutdownMedia -> + // PCMedia::SelfDestruct. Satisfies step 7 of + // https://w3c.github.io/webrtc-pc/#dom-rtcpeerconnection-close + mShutdown = true; + if (mDtlsTransport) { + mDtlsTransport->UpdateState(TransportLayer::TS_CLOSED); + } + StopImpl(); +} + +void RTCRtpTransceiver::BreakCycles() { + mSender->BreakCycles(); + mReceiver->BreakCycles(); + mWindow = nullptr; + mSendTrack = nullptr; + mSender = nullptr; + mReceiver = nullptr; + mDtlsTransport = nullptr; + mLastStableDtlsTransport = nullptr; + mPc = nullptr; +} + +// TODO: Only called from one place in PeerConnectionImpl, synchronously, when +// the JSEP engine has successfully completed an offer/answer exchange. This is +// a bit squirrely, since identity validation happens asynchronously in +// PeerConnection.jsm. This probably needs to happen once all the "in parallel" +// steps have succeeded, but before we queue the task for JS observable state +// updates. +nsresult RTCRtpTransceiver::UpdateTransport() { + if (!mHasTransport) { + return NS_OK; + } + + mReceiver->UpdateTransport(); + mSender->UpdateTransport(); + return NS_OK; +} + +nsresult RTCRtpTransceiver::UpdateConduit() { + if (mStopped) { + return NS_OK; + } + + mReceiver->UpdateConduit(); + mSender->MaybeUpdateConduit(); + + return NS_OK; +} + +void RTCRtpTransceiver::UpdatePrincipalPrivacy(PrincipalPrivacy aPrivacy) { + if (mPrincipalPrivacy == aPrivacy) { + return; + } + + mPrincipalPrivacy = aPrivacy; + mReceiver->UpdatePrincipalPrivacy(mPrincipalPrivacy); +} + +void RTCRtpTransceiver::ResetSync() { mSyncGroup = std::string(); } + +// TODO: Only called from one place in PeerConnectionImpl, synchronously, when +// the JSEP engine has successfully completed an offer/answer exchange. This is +// a bit squirrely, since identity validation happens asynchronously in +// PeerConnection.jsm. This probably needs to happen once all the "in parallel" +// steps have succeeded, but before we queue the task for JS observable state +// updates. +nsresult RTCRtpTransceiver::SyncWithMatchingVideoConduits( + nsTArray<RefPtr<RTCRtpTransceiver>>& transceivers) { + if (mStopped) { + return NS_OK; + } + + if (IsVideo()) { + MOZ_MTLOG(ML_ERROR, mPc->GetHandle() + << "[" << mMid.Ref() << "]: " << __FUNCTION__ + << " called when transceiver is not " + "video! This should never happen."); + MOZ_CRASH(); + return NS_ERROR_UNEXPECTED; + } + + std::set<std::string> myReceiveStreamIds; + myReceiveStreamIds.insert(mReceiver->GetStreamIds().begin(), + mReceiver->GetStreamIds().end()); + + for (RefPtr<RTCRtpTransceiver>& transceiver : transceivers) { + if (!transceiver->IsValid()) { + continue; + } + + if (!transceiver->IsVideo()) { + // |this| is an audio transceiver, so we skip other audio transceivers + continue; + } + + // Maybe could make this more efficient by cacheing this set, but probably + // not worth it. + for (const std::string& streamId : + transceiver->Receiver()->GetStreamIds()) { + if (myReceiveStreamIds.count(streamId)) { + // Ok, we have one video, one non-video - cross the streams! + mSyncGroup = streamId; + transceiver->mSyncGroup = streamId; + + MOZ_MTLOG(ML_DEBUG, mPc->GetHandle() + << "[" << mMid.Ref() << "]: " << __FUNCTION__ + << " Syncing " << mConduit.get() << " to " + << transceiver->mConduit.get()); + + // The sync code in call.cc only permits sync between audio stream and + // one video stream. They take the first match, so there's no point in + // continuing here. If we want to change the default, we should sort + // video streams here and only call SetSyncGroup on the chosen stream. + break; + } + } + } + + return NS_OK; +} + +bool RTCRtpTransceiver::ConduitHasPluginID(uint64_t aPluginID) { + return mConduit && mConduit->HasCodecPluginID(aPluginID); +} + +void RTCRtpTransceiver::SyncFromJsep(const JsepSession& aSession) { + MOZ_MTLOG(ML_DEBUG, mPc->GetHandle() + << "[" << mMid.Ref() << "]: " << __FUNCTION__ + << " Syncing from JSEP transceiver"); + if (mShutdown) { + // Shutdown_m has already been called, probably due to pc.close(). Just + // nod and smile. + return; + } + + mJsepTransceiver = *aSession.GetTransceiver(mTransceiverId); + + // Transceivers can stop due to JSEP negotiation, so we need to check that + if (mJsepTransceiver.IsStopped()) { + StopImpl(); + } + + mReceiver->SyncFromJsep(mJsepTransceiver); + mSender->SyncFromJsep(mJsepTransceiver); + + // mid from JSEP + if (mJsepTransceiver.IsAssociated()) { + mMid = mJsepTransceiver.GetMid(); + } else { + mMid = std::string(); + } + + // currentDirection from JSEP, but not if "this transceiver has never been + // represented in an offer/answer exchange" + if (mJsepTransceiver.HasLevel() && mJsepTransceiver.IsNegotiated()) { + if (mJsepTransceiver.mRecvTrack.GetActive()) { + if (mJsepTransceiver.mSendTrack.GetActive()) { + mCurrentDirection.SetValue(dom::RTCRtpTransceiverDirection::Sendrecv); + mHasBeenUsedToSend = true; + } else { + mCurrentDirection.SetValue(dom::RTCRtpTransceiverDirection::Recvonly); + } + } else { + if (mJsepTransceiver.mSendTrack.GetActive()) { + mCurrentDirection.SetValue(dom::RTCRtpTransceiverDirection::Sendonly); + mHasBeenUsedToSend = true; + } else { + mCurrentDirection.SetValue(dom::RTCRtpTransceiverDirection::Inactive); + } + } + } + + mShouldRemove = mJsepTransceiver.IsRemoved(); + mHasTransport = mJsepTransceiver.HasLevel() && !mJsepTransceiver.IsStopped(); +} + +void RTCRtpTransceiver::SyncToJsep(JsepSession& aSession) const { + MOZ_MTLOG(ML_DEBUG, mPc->GetHandle() + << "[" << mMid.Ref() << "]: " << __FUNCTION__ + << " Syncing to JSEP transceiver"); + + aSession.ApplyToTransceiver( + mTransceiverId, [this, self = RefPtr<const RTCRtpTransceiver>(this)]( + JsepTransceiver& aTransceiver) { + mReceiver->SyncToJsep(aTransceiver); + mSender->SyncToJsep(aTransceiver); + aTransceiver.mJsDirection = ToSdpDirection(mDirection); + if (mStopped) { + aTransceiver.Stop(); + } + }); +} + +void RTCRtpTransceiver::GetKind(nsAString& aKind) const { + // The transceiver kind of an RTCRtpTransceiver is defined by the kind of the + // associated RTCRtpReceiver's MediaStreamTrack object. + MOZ_ASSERT(mReceiver && mReceiver->Track()); + mReceiver->Track()->GetKind(aKind); +} + +void RTCRtpTransceiver::GetMid(nsAString& aMid) const { + if (!mMid.Ref().empty()) { + aMid = NS_ConvertUTF8toUTF16(mMid.Ref()); + } else { + aMid.SetIsVoid(true); + } +} + +std::string RTCRtpTransceiver::GetMidAscii() const { + if (mMid.Ref().empty()) { + return std::string(); + } + + return mMid.Ref(); +} + +void RTCRtpTransceiver::SetDirection(RTCRtpTransceiverDirection aDirection, + ErrorResult& aRv) { + if (mStopped) { + aRv.ThrowInvalidStateError("Transceiver is stopped!"); + return; + } + + if (aDirection == mDirection) { + return; + } + + SetDirectionInternal(aDirection); + + mPc->UpdateNegotiationNeeded(); +} + +void RTCRtpTransceiver::SetDirectionInternal( + RTCRtpTransceiverDirection aDirection) { + // We do not update the direction on the JsepTransceiver until sync + mDirection = aDirection; +} + +bool RTCRtpTransceiver::ShouldRemove() const { return mShouldRemove; } + +bool RTCRtpTransceiver::CanSendDTMF() const { + // Spec says: "If connection's RTCPeerConnectionState is not "connected" + // return false." We don't support that right now. This is supposed to be + // true once ICE is complete, and _all_ DTLS handshakes are also complete. We + // don't really have access to the state of _all_ of our DTLS states either. + // Our pipeline _does_ know whether SRTP/SRTCP is ready, which happens + // immediately after our transport finishes DTLS (unless there was an error), + // so this is pretty close. + // TODO (bug 1265827): Base this on RTCPeerConnectionState instead. + // TODO (bug 1623193): Tighten this up + if (!IsSending() || !mSender->GetTrack()) { + return false; + } + + // Ok, it looks like the connection is up and sending. Did we negotiate + // telephone-event? + const JsepTrackNegotiatedDetails* details = + mJsepTransceiver.mSendTrack.GetNegotiatedDetails(); + if (NS_WARN_IF(!details || !details->GetEncodingCount())) { + // What? + return false; + } + + for (size_t i = 0; i < details->GetEncodingCount(); ++i) { + const auto& encoding = details->GetEncoding(i); + for (const auto& codec : encoding.GetCodecs()) { + if (codec->mName == "telephone-event") { + return true; + } + } + } + + return false; +} + +JSObject* RTCRtpTransceiver::WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) { + return dom::RTCRtpTransceiver_Binding::Wrap(aCx, this, aGivenProto); +} + +nsPIDOMWindowInner* RTCRtpTransceiver::GetParentObject() const { + return mWindow; +} + +static void JsepCodecDescToAudioCodecConfig( + const JsepAudioCodecDescription& aCodec, Maybe<AudioCodecConfig>* aConfig) { + uint16_t pt; + + // TODO(bug 1761272): Getting the pt for a JsepAudioCodecDescription should be + // infallible. + if (NS_WARN_IF(!aCodec.GetPtAsInt(&pt))) { + MOZ_MTLOG(ML_ERROR, "Invalid payload type: " << aCodec.mDefaultPt); + MOZ_ASSERT(false); + return; + } + + // libwebrtc crashes if we attempt to configure a mono recv codec + bool sendMono = aCodec.mForceMono && aCodec.mDirection == sdp::kSend; + + *aConfig = Some(AudioCodecConfig( + pt, aCodec.mName, static_cast<int>(aCodec.mClock), + sendMono ? 1 : static_cast<int>(aCodec.mChannels), aCodec.mFECEnabled)); + (*aConfig)->mMaxPlaybackRate = static_cast<int>(aCodec.mMaxPlaybackRate); + (*aConfig)->mDtmfEnabled = aCodec.mDtmfEnabled; + (*aConfig)->mDTXEnabled = aCodec.mDTXEnabled; + (*aConfig)->mMaxAverageBitrate = aCodec.mMaxAverageBitrate; + (*aConfig)->mFrameSizeMs = aCodec.mFrameSizeMs; + (*aConfig)->mMinFrameSizeMs = aCodec.mMinFrameSizeMs; + (*aConfig)->mMaxFrameSizeMs = aCodec.mMaxFrameSizeMs; + (*aConfig)->mCbrEnabled = aCodec.mCbrEnabled; +} + +// TODO: This and the next function probably should move to JsepTransceiver +Maybe<const std::vector<UniquePtr<JsepCodecDescription>>&> +RTCRtpTransceiver::GetNegotiatedSendCodecs() const { + if (!mJsepTransceiver.mSendTrack.GetActive()) { + return Nothing(); + } + + const auto* details = mJsepTransceiver.mSendTrack.GetNegotiatedDetails(); + if (!details) { + return Nothing(); + } + + if (details->GetEncodingCount() == 0) { + return Nothing(); + } + + return SomeRef(details->GetEncoding(0).GetCodecs()); +} + +Maybe<const std::vector<UniquePtr<JsepCodecDescription>>&> +RTCRtpTransceiver::GetNegotiatedRecvCodecs() const { + if (!mJsepTransceiver.mRecvTrack.GetActive()) { + return Nothing(); + } + + const auto* details = mJsepTransceiver.mRecvTrack.GetNegotiatedDetails(); + if (!details) { + return Nothing(); + } + + if (details->GetEncodingCount() == 0) { + return Nothing(); + } + + return SomeRef(details->GetEncoding(0).GetCodecs()); +} + +// TODO: Maybe move this someplace else? +/*static*/ +void RTCRtpTransceiver::NegotiatedDetailsToAudioCodecConfigs( + const JsepTrackNegotiatedDetails& aDetails, + std::vector<AudioCodecConfig>* aConfigs) { + Maybe<AudioCodecConfig> telephoneEvent; + + if (aDetails.GetEncodingCount()) { + for (const auto& codec : aDetails.GetEncoding(0).GetCodecs()) { + if (NS_WARN_IF(codec->Type() != SdpMediaSection::kAudio)) { + MOZ_ASSERT(false, "Codec is not audio! This is a JSEP bug."); + return; + } + Maybe<AudioCodecConfig> config; + const JsepAudioCodecDescription& audio = + static_cast<const JsepAudioCodecDescription&>(*codec); + JsepCodecDescToAudioCodecConfig(audio, &config); + if (config->mName == "telephone-event") { + telephoneEvent = std::move(config); + } else { + aConfigs->push_back(std::move(*config)); + } + } + } + + // Put telephone event at the back, because webrtc.org crashes if we don't + // If we need to do even more sorting, we should use std::sort. + if (telephoneEvent) { + aConfigs->push_back(std::move(*telephoneEvent)); + } +} + +auto RTCRtpTransceiver::GetActivePayloadTypes() const + -> RefPtr<ActivePayloadTypesPromise> { + if (!mConduit) { + return ActivePayloadTypesPromise::CreateAndResolve(PayloadTypes(), + __func__); + } + + if (!mCallWrapper) { + return ActivePayloadTypesPromise::CreateAndResolve(PayloadTypes(), + __func__); + } + + return InvokeAsync(mCallWrapper->mCallThread, __func__, + [conduit = mConduit]() { + PayloadTypes pts; + pts.mSendPayloadType = conduit->ActiveSendPayloadType(); + pts.mRecvPayloadType = conduit->ActiveRecvPayloadType(); + return ActivePayloadTypesPromise::CreateAndResolve( + std::move(pts), __func__); + }); +} + +static void JsepCodecDescToVideoCodecConfig( + const JsepVideoCodecDescription& aCodec, Maybe<VideoCodecConfig>* aConfig) { + uint16_t pt; + + // TODO(bug 1761272): Getting the pt for a JsepVideoCodecDescription should be + // infallible. + if (NS_WARN_IF(!aCodec.GetPtAsInt(&pt))) { + MOZ_MTLOG(ML_ERROR, "Invalid payload type: " << aCodec.mDefaultPt); + MOZ_ASSERT(false); + return; + } + + UniquePtr<VideoCodecConfigH264> h264Config; + + if (aCodec.mName == "H264") { + h264Config = MakeUnique<VideoCodecConfigH264>(); + size_t spropSize = sizeof(h264Config->sprop_parameter_sets); + strncpy(h264Config->sprop_parameter_sets, + aCodec.mSpropParameterSets.c_str(), spropSize); + h264Config->sprop_parameter_sets[spropSize - 1] = '\0'; + h264Config->packetization_mode = + static_cast<int>(aCodec.mPacketizationMode); + h264Config->profile_level_id = static_cast<int>(aCodec.mProfileLevelId); + h264Config->tias_bw = 0; // TODO(bug 1403206) + } + + *aConfig = Some(VideoCodecConfig(pt, aCodec.mName, aCodec.mConstraints, + h264Config.get())); + + (*aConfig)->mAckFbTypes = aCodec.mAckFbTypes; + (*aConfig)->mNackFbTypes = aCodec.mNackFbTypes; + (*aConfig)->mCcmFbTypes = aCodec.mCcmFbTypes; + (*aConfig)->mRembFbSet = aCodec.RtcpFbRembIsSet(); + (*aConfig)->mFECFbSet = aCodec.mFECEnabled; + (*aConfig)->mTransportCCFbSet = aCodec.RtcpFbTransportCCIsSet(); + if (aCodec.mFECEnabled) { + uint16_t pt; + if (SdpHelper::GetPtAsInt(aCodec.mREDPayloadType, &pt)) { + (*aConfig)->mREDPayloadType = pt; + } + if (SdpHelper::GetPtAsInt(aCodec.mULPFECPayloadType, &pt)) { + (*aConfig)->mULPFECPayloadType = pt; + } + } + if (aCodec.mRtxEnabled) { + uint16_t pt; + if (SdpHelper::GetPtAsInt(aCodec.mRtxPayloadType, &pt)) { + (*aConfig)->mRTXPayloadType = pt; + } + } +} + +// TODO: Maybe move this someplace else? +/*static*/ +void RTCRtpTransceiver::NegotiatedDetailsToVideoCodecConfigs( + const JsepTrackNegotiatedDetails& aDetails, + std::vector<VideoCodecConfig>* aConfigs) { + if (aDetails.GetEncodingCount()) { + for (const auto& codec : aDetails.GetEncoding(0).GetCodecs()) { + if (NS_WARN_IF(codec->Type() != SdpMediaSection::kVideo)) { + MOZ_ASSERT(false, "Codec is not video! This is a JSEP bug."); + return; + } + Maybe<VideoCodecConfig> config; + const JsepVideoCodecDescription& video = + static_cast<const JsepVideoCodecDescription&>(*codec); + + JsepCodecDescToVideoCodecConfig(video, &config); + + config->mTias = aDetails.GetTias(); + + for (size_t i = 0; i < aDetails.GetEncodingCount(); ++i) { + const JsepTrackEncoding& jsepEncoding(aDetails.GetEncoding(i)); + if (jsepEncoding.HasFormat(video.mDefaultPt)) { + VideoCodecConfig::Encoding encoding; + encoding.rid = jsepEncoding.mRid; + config->mEncodings.push_back(encoding); + } + } + + aConfigs->push_back(std::move(*config)); + } + } +} + +void RTCRtpTransceiver::Stop(ErrorResult& aRv) { + if (mPc->IsClosed()) { + aRv.ThrowInvalidStateError("Peer connection is closed"); + return; + } + + StopImpl(); + mPc->UpdateNegotiationNeeded(); +} + +void RTCRtpTransceiver::StopImpl() { + if (mStopped) { + return; + } + + if (mCallWrapper) { + auto conduit = std::move(mConduit); + (conduit ? conduit->Shutdown() + : GenericPromise::CreateAndResolve(true, __func__)) + ->Then(GetMainThreadSerialEventTarget(), __func__, + [sender = mSender, receiver = mReceiver]() mutable { + // Shutdown pipelines when conduits are guaranteed shut down, + // so that all packets sent from conduits can be delivered. + sender->Shutdown(); + receiver->Shutdown(); + }); + mCallWrapper = nullptr; + } + mStopped = true; + mCurrentDirection.SetNull(); + + mSender->Stop(); + mReceiver->Stop(); + + auto self = nsMainThreadPtrHandle<RTCRtpTransceiver>( + new nsMainThreadPtrHolder<RTCRtpTransceiver>( + "RTCRtpTransceiver::StopImpl::self", this, false)); + mStsThread->Dispatch(NS_NewRunnableFunction( + __func__, [self] { self->mTransportHandler = nullptr; })); +} + +bool RTCRtpTransceiver::IsVideo() const { return mIsVideo; } + +bool RTCRtpTransceiver::IsSending() const { + return mCurrentDirection == Nullable(RTCRtpTransceiverDirection::Sendonly) || + mCurrentDirection == Nullable(RTCRtpTransceiverDirection::Sendrecv); +} + +bool RTCRtpTransceiver::IsReceiving() const { + return mCurrentDirection == Nullable(RTCRtpTransceiverDirection::Recvonly) || + mCurrentDirection == Nullable(RTCRtpTransceiverDirection::Sendrecv); +} + +void RTCRtpTransceiver::ChainToDomPromiseWithCodecStats( + nsTArray<RefPtr<RTCStatsPromise>> aStats, + const RefPtr<dom::Promise>& aDomPromise) { + nsTArray<RTCCodecStats> codecStats = + mPc->GetCodecStats(mPc->GetTimestampMaker().GetNow().ToDom()); + + AutoTArray< + std::tuple<RTCRtpTransceiver*, RefPtr<RTCStatsPromise::AllPromiseType>>, + 1> + statsPromises; + statsPromises.AppendElement(std::make_tuple( + this, RTCStatsPromise::All(GetMainThreadSerialEventTarget(), aStats))); + + ApplyCodecStats(std::move(codecStats), std::move(statsPromises)) + ->Then( + GetMainThreadSerialEventTarget(), __func__, + [aDomPromise, window = mWindow, + idGen = mIdGenerator](UniquePtr<RTCStatsCollection> aStats) mutable { + // Rewrite ids and merge stats collections into the final report. + AutoTArray<UniquePtr<RTCStatsCollection>, 1> stats; + stats.AppendElement(std::move(aStats)); + + RTCStatsCollection opaqueStats; + idGen->RewriteIds(std::move(stats), &opaqueStats); + + RefPtr<RTCStatsReport> report(new RTCStatsReport(window)); + report->Incorporate(opaqueStats); + + aDomPromise->MaybeResolve(std::move(report)); + }, + [aDomPromise](nsresult aError) { + aDomPromise->MaybeReject(NS_ERROR_FAILURE); + }); +} + +RefPtr<RTCStatsPromise> RTCRtpTransceiver::ApplyCodecStats( + nsTArray<RTCCodecStats> aCodecStats, + nsTArray< + std::tuple<RTCRtpTransceiver*, RefPtr<RTCStatsPromise::AllPromiseType>>> + aTransceiverStatsPromises) { + MOZ_ASSERT(NS_IsMainThread()); + // The process here is roughly: + // - Gather all inputs to the codec filtering process, including: + // - Each transceiver's transportIds + // - Each transceiver's active payload types (resolved) + // - Each transceiver's resolved stats + // + // Waiting (async) for multiple promises of different types is not supported + // by the MozPromise API (bug 1752318), so we are a bit finicky here. We + // create media::Refcountables of the types we want to resolve, and let + // these be shared across Then-functions through RefPtrs. + // + // - For each active payload type in a transceiver: + // - Register the codec stats for this payload type and transport if we + // haven't already done so + // - If it was a send payload type, assign the codec stats id for this + // payload type and transport to the transceiver's outbound-rtp and + // remote-inbound-rtp stats as codecId + // - If it was a recv payload type, assign the codec stats id for this + // payload type and transport to the transceiver's inbound-rtp and + // remote-outbound-rtp stats as codecId + // + // - Flatten all transceiver stats collections into one, and set the + // registered codec stats on it + + // Wrap codec stats in a Refcountable<> to allow sharing across promise + // handlers. + auto codecStats = MakeRefPtr<media::Refcountable<nsTArray<RTCCodecStats>>>(); + *codecStats = std::move(aCodecStats); + + struct IdComparator { + bool operator()(const RTCCodecStats& aA, const RTCCodecStats& aB) const { + return aA.mId.Value() < aB.mId.Value(); + } + }; + + // Stores distinct codec stats by id; to avoid dupes within a transport. + auto finalCodecStats = + MakeRefPtr<media::Refcountable<std::set<RTCCodecStats, IdComparator>>>(); + + // All the transceiver rtp stream stats in a single array. These stats will, + // when resolved, contain codecIds. + nsTArray<RefPtr<RTCStatsPromise>> promises( + aTransceiverStatsPromises.Length()); + + for (const auto& [transceiver, allPromise] : aTransceiverStatsPromises) { + // Per transceiver, gather up what we need to assign codecId to this + // transceiver's rtp stream stats. Register codec stats while we're at it. + auto payloadTypes = + MakeRefPtr<media::Refcountable<RTCRtpTransceiver::PayloadTypes>>(); + promises.AppendElement( + transceiver->GetActivePayloadTypes() + ->Then( + GetMainThreadSerialEventTarget(), __func__, + [payloadTypes, allPromise = allPromise]( + RTCRtpTransceiver::PayloadTypes aPayloadTypes) { + // Forward active payload types to the next Then-handler. + *payloadTypes = std::move(aPayloadTypes); + return allPromise; + }, + [] { + MOZ_CRASH("Unexpected reject"); + return RTCStatsPromise::AllPromiseType::CreateAndReject( + NS_ERROR_UNEXPECTED, __func__); + }) + ->Then( + GetMainThreadSerialEventTarget(), __func__, + [codecStats, finalCodecStats, payloadTypes, + transportId = + NS_ConvertASCIItoUTF16(transceiver->GetTransportId())]( + nsTArray<UniquePtr<RTCStatsCollection>> + aTransceiverStats) mutable { + // We have all the data we need to register codec stats and + // assign codecIds for this transceiver's rtp stream stats. + + auto report = MakeUnique<RTCStatsCollection>(); + FlattenStats(std::move(aTransceiverStats), report.get()); + + // Find the codec stats we are looking for, based on the + // transportId and the active payload types. + Maybe<RTCCodecStats&> sendCodec; + Maybe<RTCCodecStats&> recvCodec; + for (auto& codec : *codecStats) { + if (payloadTypes->mSendPayloadType.isSome() == + sendCodec.isSome() && + payloadTypes->mRecvPayloadType.isSome() == + recvCodec.isSome()) { + // We have found all the codec stats we were looking for. + break; + } + if (codec.mTransportId != transportId) { + continue; + } + if (payloadTypes->mSendPayloadType && + *payloadTypes->mSendPayloadType == + static_cast<int>(codec.mPayloadType) && + (!codec.mCodecType.WasPassed() || + codec.mCodecType.Value() == RTCCodecType::Encode)) { + MOZ_ASSERT(!sendCodec, + "At most one send codec stat per transceiver"); + sendCodec = SomeRef(codec); + } + if (payloadTypes->mRecvPayloadType && + *payloadTypes->mRecvPayloadType == + static_cast<int>(codec.mPayloadType) && + (!codec.mCodecType.WasPassed() || + codec.mCodecType.Value() == RTCCodecType::Decode)) { + MOZ_ASSERT(!recvCodec, + "At most one recv codec stat per transceiver"); + recvCodec = SomeRef(codec); + } + } + + // Register and assign codecIds for the found codec stats. + if (sendCodec) { + finalCodecStats->insert(*sendCodec); + for (auto& stat : report->mOutboundRtpStreamStats) { + stat.mCodecId.Construct(sendCodec->mId.Value()); + } + for (auto& stat : report->mRemoteInboundRtpStreamStats) { + stat.mCodecId.Construct(sendCodec->mId.Value()); + } + } + if (recvCodec) { + finalCodecStats->insert(*recvCodec); + for (auto& stat : report->mInboundRtpStreamStats) { + stat.mCodecId.Construct(recvCodec->mId.Value()); + } + for (auto& stat : report->mRemoteOutboundRtpStreamStats) { + stat.mCodecId.Construct(recvCodec->mId.Value()); + } + } + + return RTCStatsPromise::CreateAndResolve(std::move(report), + __func__); + }, + [] { + MOZ_CRASH("Unexpected reject"); + return RTCStatsPromise::CreateAndReject(NS_ERROR_UNEXPECTED, + __func__); + })); + } + + return RTCStatsPromise::All(GetMainThreadSerialEventTarget(), promises) + ->Then( + GetMainThreadSerialEventTarget(), __func__, + [finalCodecStats = std::move(finalCodecStats)]( + nsTArray<UniquePtr<RTCStatsCollection>> aStats) mutable { + auto finalStats = MakeUnique<RTCStatsCollection>(); + FlattenStats(std::move(aStats), finalStats.get()); + MOZ_ASSERT(finalStats->mCodecStats.IsEmpty()); + if (!finalStats->mCodecStats.SetCapacity(finalCodecStats->size(), + fallible)) { + mozalloc_handle_oom(0); + } + while (!finalCodecStats->empty()) { + auto node = finalCodecStats->extract(finalCodecStats->begin()); + if (!finalStats->mCodecStats.AppendElement( + std::move(node.value()), fallible)) { + mozalloc_handle_oom(0); + } + } + return RTCStatsPromise::CreateAndResolve(std::move(finalStats), + __func__); + }, + [] { + MOZ_CRASH("Unexpected reject"); + return RTCStatsPromise::CreateAndReject(NS_ERROR_UNEXPECTED, + __func__); + }); +} + +} // namespace mozilla diff --git a/dom/media/webrtc/jsapi/RTCRtpTransceiver.h b/dom/media/webrtc/jsapi/RTCRtpTransceiver.h new file mode 100644 index 0000000000..4830e465a0 --- /dev/null +++ b/dom/media/webrtc/jsapi/RTCRtpTransceiver.h @@ -0,0 +1,243 @@ +/* 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/. */ +#ifndef _TRANSCEIVERIMPL_H_ +#define _TRANSCEIVERIMPL_H_ + +#include <string> +#include "mozilla/StateMirroring.h" +#include "mozilla/RefPtr.h" +#include "nsCOMPtr.h" +#include "nsISerialEventTarget.h" +#include "nsTArray.h" +#include "mozilla/dom/MediaStreamTrack.h" +#include "ErrorList.h" +#include "jsep/JsepSession.h" +#include "transport/transportlayer.h" // For TransportLayer::State +#include "mozilla/dom/RTCRtpTransceiverBinding.h" +#include "RTCStatsReport.h" + +class nsIPrincipal; + +namespace mozilla { +class PeerIdentity; +class MediaSessionConduit; +class VideoSessionConduit; +class AudioSessionConduit; +struct AudioCodecConfig; +class VideoCodecConfig; // Why is this a class, but AudioCodecConfig a struct? +class MediaPipelineTransmit; +class MediaPipeline; +class MediaPipelineFilter; +class MediaTransportHandler; +class RTCStatsIdGenerator; +class WebrtcCallWrapper; +class JsepTrackNegotiatedDetails; +class PeerConnectionImpl; +enum class PrincipalPrivacy : uint8_t; + +namespace dom { +class RTCDtlsTransport; +class RTCDTMFSender; +class RTCRtpTransceiver; +struct RTCRtpSourceEntry; +class RTCRtpReceiver; +class RTCRtpSender; + +/** + * This is what ties all the various pieces that make up a transceiver + * together. This includes: + * MediaStreamTrack for rendering and capture + * MediaTransportHandler for RTP transmission/reception + * Audio/VideoConduit for feeding RTP/RTCP into webrtc.org for decoding, and + * feeding audio/video frames into webrtc.org for encoding into RTP/RTCP. + */ +class RTCRtpTransceiver : public nsISupports, public nsWrapperCache { + public: + /** + * |aSendTrack| might or might not be set. + */ + RTCRtpTransceiver( + nsPIDOMWindowInner* aWindow, bool aPrivacyNeeded, PeerConnectionImpl* aPc, + MediaTransportHandler* aTransportHandler, JsepSession* aJsepSession, + const std::string& aTransceiverId, bool aIsVideo, + nsISerialEventTarget* aStsThread, MediaStreamTrack* aSendTrack, + WebrtcCallWrapper* aCallWrapper, RTCStatsIdGenerator* aIdGenerator); + + void Init(const RTCRtpTransceiverInit& aInit, ErrorResult& aRv); + + bool IsValid() const { return !!mConduit; } + + nsresult UpdateTransport(); + + nsresult UpdateConduit(); + + void UpdatePrincipalPrivacy(PrincipalPrivacy aPrivacy); + + void ResetSync(); + + nsresult SyncWithMatchingVideoConduits( + nsTArray<RefPtr<RTCRtpTransceiver>>& transceivers); + + void Close(); + + void BreakCycles(); + + bool ConduitHasPluginID(uint64_t aPluginID); + + // for webidl + JSObject* WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) override; + nsPIDOMWindowInner* GetParentObject() const; + RTCRtpReceiver* Receiver() const { return mReceiver; } + RTCRtpSender* Sender() const { return mSender; } + RTCDtlsTransport* GetDtlsTransport() const { return mDtlsTransport; } + void GetKind(nsAString& aKind) const; + void GetMid(nsAString& aMid) const; + RTCRtpTransceiverDirection Direction() const { return mDirection; } + void SetDirection(RTCRtpTransceiverDirection aDirection, ErrorResult& aRv); + Nullable<RTCRtpTransceiverDirection> GetCurrentDirection() { + return mCurrentDirection; + } + void Stop(ErrorResult& aRv); + void SetDirectionInternal(RTCRtpTransceiverDirection aDirection); + bool HasBeenUsedToSend() const { return mHasBeenUsedToSend; } + + bool CanSendDTMF() const; + bool Stopped() const { return mStopped; } + void SyncToJsep(JsepSession& aSession) const; + void SyncFromJsep(const JsepSession& aSession); + std::string GetMidAscii() const; + + void SetDtlsTransport(RTCDtlsTransport* aDtlsTransport, bool aStable); + void RollbackToStableDtlsTransport(); + + std::string GetTransportId() const { + return mJsepTransceiver.mTransport.mTransportId; + } + + JsepTransceiver& GetJsepTransceiver() { return mJsepTransceiver; } + + bool IsVideo() const; + + bool IsSending() const; + + bool IsReceiving() const; + + bool ShouldRemove() const; + + Maybe<const std::vector<UniquePtr<JsepCodecDescription>>&> + GetNegotiatedSendCodecs() const; + + Maybe<const std::vector<UniquePtr<JsepCodecDescription>>&> + GetNegotiatedRecvCodecs() const; + + struct PayloadTypes { + Maybe<int> mSendPayloadType; + Maybe<int> mRecvPayloadType; + }; + using ActivePayloadTypesPromise = MozPromise<PayloadTypes, nsresult, true>; + RefPtr<ActivePayloadTypesPromise> GetActivePayloadTypes() const; + + MediaSessionConduit* GetConduit() const { return mConduit; } + + const std::string& GetJsepTransceiverId() const { return mTransceiverId; } + + void SetRemovedFromPc() { mHandlingUnlink = true; } + + // nsISupports + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + NS_DECL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(RTCRtpTransceiver) + + static void NegotiatedDetailsToAudioCodecConfigs( + const JsepTrackNegotiatedDetails& aDetails, + std::vector<AudioCodecConfig>* aConfigs); + + static void NegotiatedDetailsToVideoCodecConfigs( + const JsepTrackNegotiatedDetails& aDetails, + std::vector<VideoCodecConfig>* aConfigs); + + /* Returns a promise that will contain the stats in aStats, along with the + * codec stats (which is a PC-wide thing) */ + void ChainToDomPromiseWithCodecStats(nsTArray<RefPtr<RTCStatsPromise>> aStats, + const RefPtr<Promise>& aDomPromise); + + /** + * Takes a set of codec stats (per-peerconnection) and a set of + * transceiver/transceiver-stats-promise tuples. Filters out all referenced + * codec stats based on the transceiver's transport and rtp stream stats. + * Finally returns the flattened stats containing the filtered codec stats and + * all given per-transceiver-stats. + */ + static RefPtr<RTCStatsPromise> ApplyCodecStats( + nsTArray<RTCCodecStats> aCodecStats, + nsTArray<std::tuple<RTCRtpTransceiver*, + RefPtr<RTCStatsPromise::AllPromiseType>>> + aTransceiverStatsPromises); + + AbstractCanonical<std::string>* CanonicalMid() { return &mMid; } + AbstractCanonical<std::string>* CanonicalSyncGroup() { return &mSyncGroup; } + + private: + virtual ~RTCRtpTransceiver(); + void InitAudio(); + void InitVideo(const TrackingId& aRecvTrackingId); + void InitConduitControl(); + void StopImpl(); + + nsCOMPtr<nsPIDOMWindowInner> mWindow; + RefPtr<PeerConnectionImpl> mPc; + RefPtr<MediaTransportHandler> mTransportHandler; + const std::string mTransceiverId; + // Copy of latest from the JSEP engine. + JsepTransceiver mJsepTransceiver; + nsCOMPtr<nsISerialEventTarget> mStsThread; + // state for webrtc.org that is shared between all transceivers + RefPtr<WebrtcCallWrapper> mCallWrapper; + RefPtr<MediaStreamTrack> mSendTrack; + RefPtr<RTCStatsIdGenerator> mIdGenerator; + RefPtr<MediaSessionConduit> mConduit; + // The spec says both RTCRtpReceiver and RTCRtpSender have a slot for + // an RTCDtlsTransport. They are always the same, so we'll store it + // here. + RefPtr<RTCDtlsTransport> mDtlsTransport; + // The spec says both RTCRtpReceiver and RTCRtpSender have a slot for + // a last stable state RTCDtlsTransport. They are always the same, so + // we'll store it here. + RefPtr<RTCDtlsTransport> mLastStableDtlsTransport; + RefPtr<RTCRtpReceiver> mReceiver; + RefPtr<RTCRtpSender> mSender; + RTCRtpTransceiverDirection mDirection = RTCRtpTransceiverDirection::Sendrecv; + Nullable<RTCRtpTransceiverDirection> mCurrentDirection; + bool mStopped = false; + bool mShutdown = false; + bool mHasBeenUsedToSend = false; + PrincipalPrivacy mPrincipalPrivacy; + bool mShouldRemove = false; + bool mHasTransport = false; + bool mIsVideo; + // This is really nasty. Most of the time, PeerConnectionImpl needs to be in + // charge of unlinking each RTCRtpTransceiver, because it needs to perform + // stats queries on its way out, which requires all of the RTCRtpTransceivers + // (and their transitive dependencies) to stick around until those stats + // queries are finished. However, when an RTCRtpTransceiver is removed from + // the PeerConnectionImpl due to negotiation, the PeerConnectionImpl + // releases its reference, which means the PeerConnectionImpl cannot be in + // charge of the unlink anymore. We cannot do the unlink when this reference + // is released either, because RTCRtpTransceiver might have some work it needs + // to do first. Also, JS may be maintaining a reference to the + // RTCRtpTransceiver (or one of its dependencies), which means it must remain + // fully functional after it is removed (meaning it cannot release any of its + // dependencies, or vice versa). + bool mHandlingUnlink = false; + std::string mTransportId; + + Canonical<std::string> mMid; + Canonical<std::string> mSyncGroup; +}; + +} // namespace dom + +} // namespace mozilla + +#endif // _TRANSCEIVERIMPL_H_ diff --git a/dom/media/webrtc/jsapi/RTCSctpTransport.cpp b/dom/media/webrtc/jsapi/RTCSctpTransport.cpp new file mode 100644 index 0000000000..63424968ae --- /dev/null +++ b/dom/media/webrtc/jsapi/RTCSctpTransport.cpp @@ -0,0 +1,53 @@ +/* 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 "RTCSctpTransport.h" +#include "mozilla/dom/Event.h" +#include "mozilla/dom/EventBinding.h" +#include "mozilla/dom/RTCSctpTransportBinding.h" + +namespace mozilla::dom { + +NS_IMPL_CYCLE_COLLECTION_INHERITED(RTCSctpTransport, DOMEventTargetHelper, + mDtlsTransport) + +NS_IMPL_ADDREF_INHERITED(RTCSctpTransport, DOMEventTargetHelper) +NS_IMPL_RELEASE_INHERITED(RTCSctpTransport, DOMEventTargetHelper) + +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(RTCSctpTransport) + NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY +NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper) + +RTCSctpTransport::RTCSctpTransport(nsPIDOMWindowInner* aWindow, + RTCDtlsTransport& aDtlsTransport, + double aMaxMessageSize, + const Nullable<uint16_t>& aMaxChannels) + : DOMEventTargetHelper(aWindow), + mState(RTCSctpTransportState::Connecting), + mDtlsTransport(&aDtlsTransport), + mMaxMessageSize(aMaxMessageSize), + mMaxChannels(aMaxChannels) {} + +JSObject* RTCSctpTransport::WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) { + return RTCSctpTransport_Binding::Wrap(aCx, this, aGivenProto); +} + +void RTCSctpTransport::UpdateState(RTCSctpTransportState aState) { + if (mState == RTCSctpTransportState::Closed || mState == aState) { + return; + } + + mState = aState; + + EventInit init; + init.mBubbles = false; + init.mCancelable = false; + + RefPtr<Event> event = Event::Constructor(this, u"statechange"_ns, init); + + DispatchTrustedEvent(event); +} + +} // namespace mozilla::dom diff --git a/dom/media/webrtc/jsapi/RTCSctpTransport.h b/dom/media/webrtc/jsapi/RTCSctpTransport.h new file mode 100644 index 0000000000..8e21db5e73 --- /dev/null +++ b/dom/media/webrtc/jsapi/RTCSctpTransport.h @@ -0,0 +1,65 @@ +/* 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/. */ + +#ifndef _RTCSctpTransport_h_ +#define _RTCSctpTransport_h_ + +#include "mozilla/DOMEventTargetHelper.h" +#include "mozilla/RefPtr.h" +#include "js/RootingAPI.h" +#include "RTCDtlsTransport.h" + +class nsPIDOMWindowInner; + +namespace mozilla::dom { + +enum class RTCSctpTransportState : uint8_t; + +class RTCSctpTransport : public DOMEventTargetHelper { + public: + explicit RTCSctpTransport(nsPIDOMWindowInner* aWindow, + RTCDtlsTransport& aDtlsTransport, + double aMaxMessageSize, + const Nullable<uint16_t>& aMaxChannels); + + // nsISupports + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(RTCSctpTransport, + DOMEventTargetHelper) + + // webidl + JSObject* WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) override; + IMPL_EVENT_HANDLER(statechange) + + RTCDtlsTransport* Transport() const { return mDtlsTransport; } + RTCSctpTransportState State() const { return mState; } + double MaxMessageSize() const { return mMaxMessageSize; } + Nullable<uint16_t> GetMaxChannels() const { return mMaxChannels; } + + void SetTransport(RTCDtlsTransport& aTransport) { + mDtlsTransport = &aTransport; + } + + void SetMaxMessageSize(double aMaxMessageSize) { + mMaxMessageSize = aMaxMessageSize; + } + + void SetMaxChannels(const Nullable<uint16_t>& aMaxChannels) { + mMaxChannels = aMaxChannels; + } + + void UpdateState(RTCSctpTransportState aState); + + private: + virtual ~RTCSctpTransport() = default; + + RTCSctpTransportState mState; + RefPtr<RTCDtlsTransport> mDtlsTransport; + double mMaxMessageSize; + Nullable<uint16_t> mMaxChannels; +}; + +} // namespace mozilla::dom +#endif // _RTCSctpTransport_h_ diff --git a/dom/media/webrtc/jsapi/RTCStatsIdGenerator.cpp b/dom/media/webrtc/jsapi/RTCStatsIdGenerator.cpp new file mode 100644 index 0000000000..8b0462e223 --- /dev/null +++ b/dom/media/webrtc/jsapi/RTCStatsIdGenerator.cpp @@ -0,0 +1,90 @@ +/* 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/. */ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ + +#include "RTCStatsIdGenerator.h" + +#include <iostream> + +#include "mozilla/RandomNum.h" +#include "RTCStatsReport.h" +#include "WebrtcGlobal.h" + +namespace mozilla { + +RTCStatsIdGenerator::RTCStatsIdGenerator() + : mSalt(RandomUint64().valueOr(0xa5a5a5a5)), mCounter(0) {} + +void RTCStatsIdGenerator::RewriteIds( + nsTArray<UniquePtr<dom::RTCStatsCollection>> aFromStats, + dom::RTCStatsCollection* aIntoReport) { + // Rewrite an Optional id + auto rewriteId = [&](dom::Optional<nsString>& id) { + if (id.WasPassed()) { + id.Value() = Id(id.Value()); + } + }; + + auto rewriteIds = [&](auto& aList, auto... aParam) { + for (auto& stat : aList) { + (rewriteId(stat.*aParam), ...); + } + }; + + // Involves a lot of copying, since webidl dictionaries don't have + // move semantics. Oh well. + + // Create a temporary to avoid double-rewriting any stats already in + // aIntoReport. + auto stats = MakeUnique<dom::RTCStatsCollection>(); + dom::FlattenStats(std::move(aFromStats), stats.get()); + + using S = dom::RTCStats; + using ICPS = dom::RTCIceCandidatePairStats; + using RSS = dom::RTCRtpStreamStats; + using IRSS = dom::RTCInboundRtpStreamStats; + using ORSS = dom::RTCOutboundRtpStreamStats; + using RIRSS = dom::RTCRemoteInboundRtpStreamStats; + using RORSS = dom::RTCRemoteOutboundRtpStreamStats; + + rewriteIds(stats->mIceCandidatePairStats, &S::mId, &ICPS::mLocalCandidateId, + &ICPS::mRemoteCandidateId); + rewriteIds(stats->mIceCandidateStats, &S::mId); + rewriteIds(stats->mInboundRtpStreamStats, &S::mId, &IRSS::mRemoteId, + &RSS::mCodecId); + rewriteIds(stats->mOutboundRtpStreamStats, &S::mId, &ORSS::mRemoteId, + &RSS::mCodecId); + rewriteIds(stats->mRemoteInboundRtpStreamStats, &S::mId, &RIRSS::mLocalId, + &RSS::mCodecId); + rewriteIds(stats->mRemoteOutboundRtpStreamStats, &S::mId, &RORSS::mLocalId, + &RSS::mCodecId); + rewriteIds(stats->mCodecStats, &S::mId); + rewriteIds(stats->mRtpContributingSourceStats, &S::mId); + rewriteIds(stats->mTrickledIceCandidateStats, &S::mId); + rewriteIds(stats->mDataChannelStats, &S::mId); + + dom::MergeStats(std::move(stats), aIntoReport); +} + +nsString RTCStatsIdGenerator::Id(const nsString& aKey) { + if (!aKey.Length()) { + MOZ_ASSERT(aKey.Length(), "Stats IDs should never be empty."); + return aKey; + } + if (mAllocated.find(aKey) == mAllocated.end()) { + mAllocated[aKey] = Generate(); + } + return mAllocated[aKey]; +} + +nsString RTCStatsIdGenerator::Generate() { + auto random = RandomUint64().valueOr(0x1a22); + auto idNum = static_cast<uint32_t>(mSalt ^ ((mCounter++ << 16) | random)); + nsString id; + id.AppendInt(idNum, 16); // Append as hex + return id; +} + +} // namespace mozilla diff --git a/dom/media/webrtc/jsapi/RTCStatsIdGenerator.h b/dom/media/webrtc/jsapi/RTCStatsIdGenerator.h new file mode 100644 index 0000000000..1391c029ad --- /dev/null +++ b/dom/media/webrtc/jsapi/RTCStatsIdGenerator.h @@ -0,0 +1,42 @@ +/* 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/. */ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ + +#ifndef _RTCSTATSIDGENERATOR_H_ +#define _RTCSTATSIDGENERATOR_H_ + +#include <map> + +#include "mozilla/Atomics.h" +#include "mozilla/UniquePtr.h" +#include "nsISupportsImpl.h" +#include "nsString.h" +#include "nsTArray.h" + +namespace mozilla { +namespace dom { +struct RTCStatsCollection; +} // namespace dom + +class RTCStatsIdGenerator { + public: + RTCStatsIdGenerator(); + NS_INLINE_DECL_THREADSAFE_REFCOUNTING(RTCStatsIdGenerator); + + void RewriteIds(nsTArray<UniquePtr<dom::RTCStatsCollection>> aFromStats, + dom::RTCStatsCollection* aIntoReport); + + private: + virtual ~RTCStatsIdGenerator(){}; + nsString Id(const nsString& aKey); + nsString Generate(); + + const uint64_t mSalt; + uint64_t mCounter; + std::map<nsString, nsString> mAllocated; +}; + +} // namespace mozilla +#endif diff --git a/dom/media/webrtc/jsapi/RTCStatsReport.cpp b/dom/media/webrtc/jsapi/RTCStatsReport.cpp new file mode 100644 index 0000000000..9f39eb3865 --- /dev/null +++ b/dom/media/webrtc/jsapi/RTCStatsReport.cpp @@ -0,0 +1,213 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* 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 https://mozilla.org/MPL/2.0/. */ + +#include "RTCStatsReport.h" +#include "libwebrtcglue/SystemTime.h" +#include "mozilla/dom/Performance.h" +#include "nsRFPService.h" +#include "WebrtcGlobal.h" + +namespace mozilla::dom { + +RTCStatsTimestampState::RTCStatsTimestampState() + : mRandomTimelineSeed(0), + mStartDomRealtime(WebrtcSystemTimeBase()), + mStartRealtime( + WebrtcSystemTime() - + webrtc::TimeDelta::Micros( + (TimeStamp::Now() - mStartDomRealtime).ToMicroseconds())), + mRTPCallerType(RTPCallerType::Normal), + mStartWallClockRaw( + PerformanceService::GetOrCreate()->TimeOrigin(mStartDomRealtime)) {} + +RTCStatsTimestampState::RTCStatsTimestampState(Performance& aPerformance) + : mRandomTimelineSeed(aPerformance.GetRandomTimelineSeed()), + mStartDomRealtime(aPerformance.CreationTimeStamp()), + mStartRealtime( + WebrtcSystemTime() - + webrtc::TimeDelta::Micros( + (TimeStamp::Now() - mStartDomRealtime).ToMicroseconds())), + mRTPCallerType(aPerformance.GetRTPCallerType()), + mStartWallClockRaw( + PerformanceService::GetOrCreate()->TimeOrigin(mStartDomRealtime)) {} + +TimeStamp RTCStatsTimestamp::ToMozTime() const { return mMozTime; } + +webrtc::Timestamp RTCStatsTimestamp::ToRealtime() const { + return ToDomRealtime() + + webrtc::TimeDelta::Micros(mState.mStartRealtime.us()); +} + +webrtc::Timestamp RTCStatsTimestamp::To1Jan1970() const { + return ToDomRealtime() + webrtc::TimeDelta::Millis(mState.mStartWallClockRaw); +} + +webrtc::Timestamp RTCStatsTimestamp::ToNtp() const { + return To1Jan1970() + webrtc::TimeDelta::Seconds(webrtc::kNtpJan1970); +} + +webrtc::Timestamp RTCStatsTimestamp::ToDomRealtime() const { + return webrtc::Timestamp::Micros( + (mMozTime - mState.mStartDomRealtime).ToMicroseconds()); +} + +DOMHighResTimeStamp RTCStatsTimestamp::ToDom() const { + // webrtc-pc says to use performance.timeOrigin + performance.now(), but + // keeping a Performance object around is difficult because it is + // main-thread-only. So, we perform the same calculation here. Note that this + // can be very different from the current wall-clock time because of changes + // to the wall clock, or monotonic clock drift over long periods of time. + // We are very careful to do exactly what Performance does, to avoid timestamp + // discrepancies. + + DOMHighResTimeStamp realtime = ToDomRealtime().ms<double>(); + // mRandomTimelineSeed is not set in the unit-tests. + if (mState.mRandomTimelineSeed) { + realtime = nsRFPService::ReduceTimePrecisionAsMSecs( + realtime, mState.mRandomTimelineSeed, mState.mRTPCallerType); + } + + // Ugh. Performance::TimeOrigin is not constant, which means we need to + // emulate this weird behavior so our time stamps are consistent with JS + // timeOrigin. This is based on the code here: + // https://searchfox.org/mozilla-central/rev/ + // 053826b10f838f77c27507e5efecc96e34718541/dom/performance/Performance.cpp#111-117 + DOMHighResTimeStamp start = nsRFPService::ReduceTimePrecisionAsMSecs( + mState.mStartWallClockRaw, 0, mState.mRTPCallerType); + + return start + realtime; +} + +/* static */ RTCStatsTimestamp RTCStatsTimestamp::FromMozTime( + const RTCStatsTimestampMaker& aMaker, TimeStamp aMozTime) { + return RTCStatsTimestamp(aMaker.mState, aMozTime); +} + +/* static */ RTCStatsTimestamp RTCStatsTimestamp::FromRealtime( + const RTCStatsTimestampMaker& aMaker, webrtc::Timestamp aRealtime) { + return FromDomRealtime( + aMaker, + aRealtime - webrtc::TimeDelta::Micros(aMaker.mState.mStartRealtime.us())); +} + +/* static */ RTCStatsTimestamp RTCStatsTimestamp::From1Jan1970( + const RTCStatsTimestampMaker& aMaker, webrtc::Timestamp a1Jan1970) { + const auto& state = aMaker.mState; + return FromDomRealtime( + aMaker, a1Jan1970 - webrtc::TimeDelta::Millis(state.mStartWallClockRaw)); +} + +/* static */ RTCStatsTimestamp RTCStatsTimestamp::FromNtp( + const RTCStatsTimestampMaker& aMaker, webrtc::Timestamp aNtpTime) { + const auto& state = aMaker.mState; + const auto domRealtime = aNtpTime - + webrtc::TimeDelta::Seconds(webrtc::kNtpJan1970) - + webrtc::TimeDelta::Millis(state.mStartWallClockRaw); + // Ntp times exposed by libwebrtc to stats are always **rounded** to + // milliseconds. That means they can jump up to half a millisecond into the + // future. We compensate for that here so that things seem consistent to js. + return FromDomRealtime(aMaker, domRealtime - webrtc::TimeDelta::Micros(500)); +} + +/* static */ RTCStatsTimestamp RTCStatsTimestamp::FromDomRealtime( + const RTCStatsTimestampMaker& aMaker, webrtc::Timestamp aDomRealtime) { + return RTCStatsTimestamp(aMaker.mState, aMaker.mState.mStartDomRealtime + + TimeDuration::FromMicroseconds( + aDomRealtime.us<double>())); +} + +RTCStatsTimestamp::RTCStatsTimestamp(RTCStatsTimestampState aState, + TimeStamp aMozTime) + : mState(aState), mMozTime(aMozTime) {} + +RTCStatsTimestampMaker::RTCStatsTimestampMaker(RTCStatsTimestampState aState) + : mState(aState) {} + +/* static */ +RTCStatsTimestampMaker RTCStatsTimestampMaker::Create( + nsPIDOMWindowInner* aWindow /* = nullptr */) { + if (!aWindow) { + return RTCStatsTimestampMaker(RTCStatsTimestampState()); + } + if (Performance* p = aWindow->GetPerformance()) { + return RTCStatsTimestampMaker(RTCStatsTimestampState(*p)); + } + return RTCStatsTimestampMaker(RTCStatsTimestampState()); +} + +RTCStatsTimestamp RTCStatsTimestampMaker::GetNow() const { + return RTCStatsTimestamp::FromMozTime(*this, TimeStamp::Now()); +} + +NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(RTCStatsReport, mParent) + +RTCStatsReport::RTCStatsReport(nsPIDOMWindowInner* aParent) + : mParent(aParent) {} + +/*static*/ +already_AddRefed<RTCStatsReport> RTCStatsReport::Constructor( + const GlobalObject& aGlobal) { + nsCOMPtr<nsPIDOMWindowInner> window( + do_QueryInterface(aGlobal.GetAsSupports())); + RefPtr<RTCStatsReport> report(new RTCStatsReport(window)); + return report.forget(); +} + +JSObject* RTCStatsReport::WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) { + return RTCStatsReport_Binding::Wrap(aCx, this, aGivenProto); +} + +void RTCStatsReport::Incorporate(RTCStatsCollection& aStats) { + ForAllPublicRTCStatsCollectionMembers( + aStats, [&](auto... aMember) { (SetRTCStats(aMember), ...); }); +} + +void RTCStatsReport::Set(const nsAString& aKey, JS::Handle<JSObject*> aValue, + ErrorResult& aRv) { + RTCStatsReport_Binding::MaplikeHelpers::Set(this, aKey, aValue, aRv); +} + +namespace { +template <size_t I, typename... Ts> +bool MoveInto(std::tuple<Ts...>& aFrom, std::tuple<Ts*...>& aInto) { + return std::get<I>(aInto)->AppendElements(std::move(std::get<I>(aFrom)), + fallible); +} + +template <size_t... Is, typename... Ts> +bool MoveInto(std::tuple<Ts...>&& aFrom, std::tuple<Ts*...>& aInto, + std::index_sequence<Is...>) { + return (... && MoveInto<Is>(aFrom, aInto)); +} + +template <typename... Ts> +bool MoveInto(std::tuple<Ts...>&& aFrom, std::tuple<Ts*...>& aInto) { + return MoveInto(std::move(aFrom), aInto, std::index_sequence_for<Ts...>()); +} +} // namespace + +void MergeStats(UniquePtr<RTCStatsCollection> aFromStats, + RTCStatsCollection* aIntoStats) { + auto fromTuple = ForAllRTCStatsCollectionMembers( + *aFromStats, + [&](auto&... aMember) { return std::make_tuple(std::move(aMember)...); }); + auto intoTuple = ForAllRTCStatsCollectionMembers( + *aIntoStats, + [&](auto&... aMember) { return std::make_tuple(&aMember...); }); + if (!MoveInto(std::move(fromTuple), intoTuple)) { + mozalloc_handle_oom(0); + } +} + +void FlattenStats(nsTArray<UniquePtr<RTCStatsCollection>> aFromStats, + RTCStatsCollection* aIntoStats) { + for (auto& stats : aFromStats) { + MergeStats(std::move(stats), aIntoStats); + } +} + +} // namespace mozilla::dom diff --git a/dom/media/webrtc/jsapi/RTCStatsReport.h b/dom/media/webrtc/jsapi/RTCStatsReport.h new file mode 100644 index 0000000000..97bf3daa52 --- /dev/null +++ b/dom/media/webrtc/jsapi/RTCStatsReport.h @@ -0,0 +1,205 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* 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 https://mozilla.org/MPL/2.0/. */ + +#ifndef RTCStatsReport_h_ +#define RTCStatsReport_h_ + +#include "api/units/timestamp.h" // webrtc::Timestamp +#include "js/RootingAPI.h" // JS::Rooted +#include "js/Value.h" +#include "mozilla/dom/AutoEntryScript.h" +#include "mozilla/MozPromise.h" +#include "mozilla/TimeStamp.h" +#include "mozilla/dom/PerformanceService.h" +#include "mozilla/dom/RTCStatsReportBinding.h" // RTCStatsCollection +#include "mozilla/dom/ToJSValue.h" +#include "mozilla/ErrorResult.h" +#include "mozilla/UniquePtr.h" +#include "nsCOMPtr.h" +#include "nsIGlobalObject.h" +#include "nsPIDOMWindow.h" // nsPIDOMWindowInner +#include "nsContentUtils.h" +#include "nsWrapperCache.h" +#include "prtime.h" // PR_Now + +namespace mozilla { + +extern TimeStamp WebrtcSystemTimeBase(); + +namespace dom { + +/** + * Keeps the state needed to convert RTCStatsTimestamps. + */ +struct RTCStatsTimestampState { + RTCStatsTimestampState(); + explicit RTCStatsTimestampState(Performance& aPerformance); + + RTCStatsTimestampState(const RTCStatsTimestampState&) = default; + + // These members are sampled when a non-copy constructor is called. + + // Performance's random timeline seed. + const uint64_t mRandomTimelineSeed; + // TimeStamp::Now() when the members were sampled. This is equivalent to time + // 0 in DomRealtime. + const TimeStamp mStartDomRealtime; + // WebrtcSystemTime() when the members were sampled. This represents the same + // point in time as mStartDomRealtime, but as a webrtc timestamp. + const webrtc::Timestamp mStartRealtime; + // Performance's RTPCallerType. + const RTPCallerType mRTPCallerType; + // Performance.timeOrigin for mStartDomRealtime when the members were sampled. + const DOMHighResTimeStamp mStartWallClockRaw; +}; + +/** + * Classes that facilitate creating timestamps for webrtc stats by mimicking + * dom::Performance, as well as getting and converting timestamps for libwebrtc + * and our integration with it. + * + * They use the same clock to avoid drift and inconsistencies, base on + * mozilla::TimeStamp, and convert to and from these time bases: + * - Moz : Monotonic, unspecified (but constant) and inaccessible epoch, + * as implemented by mozilla::TimeStamp + * - Realtime : Monotonic, unspecified (but constant) epoch. + * - 1Jan1970 : Monotonic, unix epoch (00:00:00 UTC on 1 January 1970). + * - Ntp : Monotonic, ntp epoch (00:00:00 UTC on 1 January 1900). + * - Dom : Monotonic, milliseconds since unix epoch, as the timestamps + * defined by webrtc-pc. Corresponds to Performance.timeOrigin + + * Performance.now(). Has reduced precision. + * - DomRealtime: Like Dom, but with full precision. + * - WallClock : Non-monotonic, unix epoch. Not used here since it is + * non-monotonic and cannot be correlated to the other time + * bases. + */ +class RTCStatsTimestampMaker; +class RTCStatsTimestamp { + public: + TimeStamp ToMozTime() const; + webrtc::Timestamp ToRealtime() const; + webrtc::Timestamp To1Jan1970() const; + webrtc::Timestamp ToNtp() const; + webrtc::Timestamp ToDomRealtime() const; + DOMHighResTimeStamp ToDom() const; + + static RTCStatsTimestamp FromMozTime(const RTCStatsTimestampMaker& aMaker, + TimeStamp aMozTime); + static RTCStatsTimestamp FromRealtime(const RTCStatsTimestampMaker& aMaker, + webrtc::Timestamp aRealtime); + static RTCStatsTimestamp From1Jan1970(const RTCStatsTimestampMaker& aMaker, + webrtc::Timestamp aRealtime); + static RTCStatsTimestamp FromNtp(const RTCStatsTimestampMaker& aMaker, + webrtc::Timestamp aRealtime); + static RTCStatsTimestamp FromDomRealtime(const RTCStatsTimestampMaker& aMaker, + webrtc::Timestamp aDomRealtime); + // There is on purpose no conversion functions from DOMHighResTimeStamp + // because of the loss in precision of a floating point to integer conversion. + + private: + RTCStatsTimestamp(RTCStatsTimestampState aState, TimeStamp aMozTime); + + const RTCStatsTimestampState mState; + const TimeStamp mMozTime; +}; + +class RTCStatsTimestampMaker { + public: + static RTCStatsTimestampMaker Create(nsPIDOMWindowInner* aWindow = nullptr); + + RTCStatsTimestamp GetNow() const; + + const RTCStatsTimestampState mState; + + private: + explicit RTCStatsTimestampMaker(RTCStatsTimestampState aState); +}; + +// TODO(bug 1588303): If we ever get move semantics for webidl dictionaries, we +// can stop wrapping these in UniquePtr, which will allow us to simplify code +// in several places. +typedef MozPromise<UniquePtr<RTCStatsCollection>, nsresult, true> + RTCStatsPromise; + +typedef MozPromise<UniquePtr<RTCStatsReportInternal>, nsresult, true> + RTCStatsReportPromise; + +class RTCStatsReport final : public nsWrapperCache { + public: + NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(RTCStatsReport) + NS_DECL_CYCLE_COLLECTION_NATIVE_WRAPPERCACHE_CLASS(RTCStatsReport) + + explicit RTCStatsReport(nsPIDOMWindowInner* aParent); + + // TODO(bug 1586109): Remove this once we no longer have to create empty + // RTCStatsReports from JS. + static already_AddRefed<RTCStatsReport> Constructor( + const GlobalObject& aGlobal); + + void Incorporate(RTCStatsCollection& aStats); + + nsPIDOMWindowInner* GetParentObject() const { return mParent; } + + JSObject* WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) override; + + private: + ~RTCStatsReport() = default; + void Set(const nsAString& aKey, JS::Handle<JSObject*> aValue, + ErrorResult& aRv); + + template <typename T> + nsresult SetRTCStats(Sequence<T>& aValues) { + for (T& value : aValues) { + nsresult rv = SetRTCStats(value); + if (NS_FAILED(rv)) { + return rv; + } + } + return NS_OK; + } + + // We cannot just declare this as SetRTCStats(RTCStats&), because the + // conversion function that ToJSValue uses is non-virtual. + template <typename T> + nsresult SetRTCStats(T& aValue) { + static_assert(std::is_base_of<RTCStats, T>::value, + "SetRTCStats is for setting RTCStats only"); + + if (!aValue.mId.WasPassed()) { + return NS_OK; + } + + const nsString key(aValue.mId.Value()); + + // Cargo-culted from dom::Promise; converts aValue to a JSObject + AutoEntryScript aes(mParent->AsGlobal()->GetGlobalJSObject(), + "RTCStatsReport::SetRTCStats"); + JSContext* cx = aes.cx(); + JS::Rooted<JS::Value> val(cx); + if (!ToJSValue(cx, std::forward<T>(aValue), &val)) { + return NS_ERROR_FAILURE; + } + JS::Rooted<JSObject*> jsObject(cx, &val.toObject()); + + ErrorResult rv; + Set(key, jsObject, rv); + return rv.StealNSResult(); + } + + nsCOMPtr<nsPIDOMWindowInner> mParent; +}; + +void MergeStats(UniquePtr<dom::RTCStatsCollection> aFromStats, + dom::RTCStatsCollection* aIntoStats); + +void FlattenStats(nsTArray<UniquePtr<dom::RTCStatsCollection>> aFromStats, + dom::RTCStatsCollection* aIntoStats); + +} // namespace dom +} // namespace mozilla + +#endif // RTCStatsReport_h_ diff --git a/dom/media/webrtc/jsapi/RemoteTrackSource.cpp b/dom/media/webrtc/jsapi/RemoteTrackSource.cpp new file mode 100644 index 0000000000..41c679e431 --- /dev/null +++ b/dom/media/webrtc/jsapi/RemoteTrackSource.cpp @@ -0,0 +1,73 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* 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 "RemoteTrackSource.h" + +#include "MediaStreamError.h" +#include "MediaTrackGraph.h" +#include "RTCRtpReceiver.h" + +namespace mozilla { + +NS_IMPL_ADDREF_INHERITED(RemoteTrackSource, dom::MediaStreamTrackSource) +NS_IMPL_RELEASE_INHERITED(RemoteTrackSource, dom::MediaStreamTrackSource) +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(RemoteTrackSource) +NS_INTERFACE_MAP_END_INHERITING(dom::MediaStreamTrackSource) +NS_IMPL_CYCLE_COLLECTION_CLASS(RemoteTrackSource) +NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(RemoteTrackSource, + dom::MediaStreamTrackSource) + tmp->Destroy(); + NS_IMPL_CYCLE_COLLECTION_UNLINK(mReceiver) +NS_IMPL_CYCLE_COLLECTION_UNLINK_END +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(RemoteTrackSource, + dom::MediaStreamTrackSource) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mReceiver) +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END + +RemoteTrackSource::RemoteTrackSource(SourceMediaTrack* aStream, + dom::RTCRtpReceiver* aReceiver, + nsIPrincipal* aPrincipal, + const nsString& aLabel, + TrackingId aTrackingId) + : dom::MediaStreamTrackSource(aPrincipal, aLabel, std::move(aTrackingId)), + mStream(aStream), + mReceiver(aReceiver) {} + +RemoteTrackSource::~RemoteTrackSource() { Destroy(); } + +void RemoteTrackSource::Destroy() { + if (mStream) { + MOZ_ASSERT(!mStream->IsDestroyed()); + mStream->End(); + mStream->Destroy(); + mStream = nullptr; + + GetMainThreadSerialEventTarget()->Dispatch(NewRunnableMethod( + "RemoteTrackSource::ForceEnded", this, &RemoteTrackSource::ForceEnded)); + } +} + +auto RemoteTrackSource::ApplyConstraints( + const dom::MediaTrackConstraints& aConstraints, dom::CallerType aCallerType) + -> RefPtr<ApplyConstraintsPromise> { + return ApplyConstraintsPromise::CreateAndReject( + MakeRefPtr<MediaMgrError>( + dom::MediaStreamError::Name::OverconstrainedError, ""), + __func__); +} + +void RemoteTrackSource::SetPrincipal(nsIPrincipal* aPrincipal) { + mPrincipal = aPrincipal; + PrincipalChanged(); +} + +void RemoteTrackSource::SetMuted(bool aMuted) { MutedChanged(aMuted); } + +void RemoteTrackSource::ForceEnded() { OverrideEnded(); } + +SourceMediaTrack* RemoteTrackSource::Stream() const { return mStream; } + +} // namespace mozilla diff --git a/dom/media/webrtc/jsapi/RemoteTrackSource.h b/dom/media/webrtc/jsapi/RemoteTrackSource.h new file mode 100644 index 0000000000..be730f0030 --- /dev/null +++ b/dom/media/webrtc/jsapi/RemoteTrackSource.h @@ -0,0 +1,64 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* 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/. */ + +#ifndef DOM_MEDIA_WEBRTC_JSAPI_REMOTETRACKSOURCE_H_ +#define DOM_MEDIA_WEBRTC_JSAPI_REMOTETRACKSOURCE_H_ + +#include "MediaStreamTrack.h" + +namespace mozilla { + +namespace dom { +class RTCRtpReceiver; +} + +class SourceMediaTrack; + +class RemoteTrackSource : public dom::MediaStreamTrackSource { + public: + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(RemoteTrackSource, + dom::MediaStreamTrackSource) + + RemoteTrackSource(SourceMediaTrack* aStream, dom::RTCRtpReceiver* aReceiver, + nsIPrincipal* aPrincipal, const nsString& aLabel, + TrackingId aTrackingId); + + void Destroy() override; + + dom::MediaSourceEnum GetMediaSource() const override { + return dom::MediaSourceEnum::Other; + } + + RefPtr<ApplyConstraintsPromise> ApplyConstraints( + const dom::MediaTrackConstraints& aConstraints, + dom::CallerType aCallerType) override; + + void Stop() override { + // XXX (Bug 1314270): Implement rejection logic if necessary when we have + // clarity in the spec. + } + + void Disable() override {} + + void Enable() override {} + + void SetPrincipal(nsIPrincipal* aPrincipal); + void SetMuted(bool aMuted); + void ForceEnded(); + + SourceMediaTrack* Stream() const; + + private: + virtual ~RemoteTrackSource(); + + RefPtr<SourceMediaTrack> mStream; + RefPtr<dom::RTCRtpReceiver> mReceiver; +}; + +} // namespace mozilla + +#endif // DOM_MEDIA_WEBRTC_JSAPI_REMOTETRACKSOURCE_H_ diff --git a/dom/media/webrtc/jsapi/WebrtcGlobalChild.h b/dom/media/webrtc/jsapi/WebrtcGlobalChild.h new file mode 100644 index 0000000000..147b4b44f0 --- /dev/null +++ b/dom/media/webrtc/jsapi/WebrtcGlobalChild.h @@ -0,0 +1,42 @@ +/* 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/. */ + +#ifndef _WEBRTC_GLOBAL_CHILD_H_ +#define _WEBRTC_GLOBAL_CHILD_H_ + +#include "mozilla/dom/PWebrtcGlobalChild.h" + +namespace mozilla::dom { + +class WebrtcGlobalChild : public PWebrtcGlobalChild { + friend class ContentChild; + + bool mShutdown; + + MOZ_IMPLICIT WebrtcGlobalChild(); + virtual void ActorDestroy(ActorDestroyReason aWhy) override; + + virtual mozilla::ipc::IPCResult RecvGetStats( + const nsAString& aPcIdFilter, GetStatsResolver&& aResolve) override; + virtual mozilla::ipc::IPCResult RecvClearStats() override; + // MOZ_CAN_RUN_SCRIPT_BOUNDARY because we can't do MOZ_CAN_RUN_SCRIPT in + // ipdl-generated things yet. + MOZ_CAN_RUN_SCRIPT_BOUNDARY + virtual mozilla::ipc::IPCResult RecvGetLog( + GetLogResolver&& aResolve) override; + virtual mozilla::ipc::IPCResult RecvClearLog() override; + virtual mozilla::ipc::IPCResult RecvSetAecLogging( + const bool& aEnable) override; + virtual mozilla::ipc::IPCResult RecvSetDebugMode(const int& aLevel) override; + + static WebrtcGlobalChild* GetOrSet(const Maybe<WebrtcGlobalChild*>& aChild); + + public: + virtual ~WebrtcGlobalChild(); + static WebrtcGlobalChild* Get(); +}; + +} // namespace mozilla::dom + +#endif // _WEBRTC_GLOBAL_CHILD_H_ diff --git a/dom/media/webrtc/jsapi/WebrtcGlobalInformation.cpp b/dom/media/webrtc/jsapi/WebrtcGlobalInformation.cpp new file mode 100644 index 0000000000..7d0a9e64b1 --- /dev/null +++ b/dom/media/webrtc/jsapi/WebrtcGlobalInformation.cpp @@ -0,0 +1,829 @@ +/* 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 "WebrtcGlobalInformation.h" +#include "WebrtcGlobalStatsHistory.h" +#include "mozilla/Assertions.h" +#include "mozilla/StaticPtr.h" +#include "mozilla/dom/PWebrtcGlobal.h" +#include "mozilla/dom/PWebrtcGlobalChild.h" +#include "mozilla/media/webrtc/WebrtcGlobal.h" +#include "WebrtcGlobalChild.h" +#include "WebrtcGlobalParent.h" + +#include <algorithm> +#include <vector> +#include <type_traits> + +#include "mozilla/dom/WebrtcGlobalInformationBinding.h" +#include "mozilla/dom/RTCStatsReportBinding.h" // for RTCStatsReportInternal +#include "mozilla/dom/ContentChild.h" + +#include "nsISupports.h" +#include "nsITimer.h" +#include "nsLiteralString.h" +#include "nsNetCID.h" // NS_SOCKETTRANSPORTSERVICE_CONTRACTID +#include "nsServiceManagerUtils.h" // do_GetService +#include "nsXULAppAPI.h" +#include "mozilla/ErrorResult.h" +#include "nsProxyRelease.h" // nsMainThreadPtrHolder +#include "mozilla/Telemetry.h" +#include "mozilla/Unused.h" +#include "mozilla/RefPtr.h" +#include "mozilla/ClearOnShutdown.h" + +#include "common/browser_logging/WebRtcLog.h" +#include "nsString.h" +#include "transport/runnable_utils.h" +#include "MediaTransportHandler.h" +#include "PeerConnectionCtx.h" +#include "PeerConnectionImpl.h" + +#ifdef XP_WIN +# include <process.h> +#endif + +namespace mozilla::dom { + +using StatsRequestCallback = + nsMainThreadPtrHandle<WebrtcGlobalStatisticsCallback>; + +using LogRequestCallback = nsMainThreadPtrHandle<WebrtcGlobalLoggingCallback>; + +class WebrtcContentParents { + public: + static WebrtcGlobalParent* Alloc(); + static void Dealloc(WebrtcGlobalParent* aParent); + static bool Empty() { return sContentParents.empty(); } + static const std::vector<RefPtr<WebrtcGlobalParent>>& GetAll() { + return sContentParents; + } + + WebrtcContentParents() = delete; + WebrtcContentParents(const WebrtcContentParents&) = delete; + WebrtcContentParents& operator=(const WebrtcContentParents&) = delete; + + private: + static std::vector<RefPtr<WebrtcGlobalParent>> sContentParents; +}; + +std::vector<RefPtr<WebrtcGlobalParent>> WebrtcContentParents::sContentParents; + +WebrtcGlobalParent* WebrtcContentParents::Alloc() { + RefPtr<WebrtcGlobalParent> cp = new WebrtcGlobalParent; + sContentParents.push_back(cp); + return cp.get(); +} + +void WebrtcContentParents::Dealloc(WebrtcGlobalParent* aParent) { + if (aParent) { + aParent->mShutdown = true; + auto cp = + std::find(sContentParents.begin(), sContentParents.end(), aParent); + if (cp != sContentParents.end()) { + sContentParents.erase(cp); + } + } +} + +static PeerConnectionCtx* GetPeerConnectionCtx() { + if (PeerConnectionCtx::isActive()) { + MOZ_ASSERT(PeerConnectionCtx::GetInstance()); + return PeerConnectionCtx::GetInstance(); + } + return nullptr; +} + +static nsTArray<dom::RTCStatsReportInternal>& GetWebrtcGlobalStatsStash() { + static StaticAutoPtr<nsTArray<dom::RTCStatsReportInternal>> sStash; + if (!sStash) { + sStash = new nsTArray<dom::RTCStatsReportInternal>(); + ClearOnShutdown(&sStash); + } + return *sStash; +} + +static RefPtr<PWebrtcGlobalParent::GetStatsPromise> +GetStatsPromiseForThisProcess(const nsAString& aPcIdFilter) { + nsTArray<RefPtr<dom::RTCStatsReportPromise>> promises; + + std::set<nsString> pcids; + if (auto* ctx = GetPeerConnectionCtx()) { + // Grab stats for PCs that still exist + ctx->ForEachPeerConnection([&](PeerConnectionImpl* aPc) { + if (!aPcIdFilter.IsEmpty() && + !aPcIdFilter.EqualsASCII(aPc->GetIdAsAscii().c_str())) { + return; + } + if (!aPc->IsClosed() || !aPc->LongTermStatsIsDisabled()) { + nsString id; + aPc->GetId(id); + pcids.insert(id); + promises.AppendElement(aPc->GetStats(nullptr, true)); + } + }); + + // Grab previously stashed stats, if they aren't dupes, and ensure they + // are marked closed. (In a content process, this should already have + // happened, but in the parent process, the stash will contain the last + // observed stats from the content processes. From the perspective of the + // parent process, these are assumed closed unless we see new stats from the + // content process that say otherwise.) + for (auto& report : GetWebrtcGlobalStatsStash()) { + report.mClosed = true; + if ((aPcIdFilter.IsEmpty() || aPcIdFilter == report.mPcid) && + !pcids.count(report.mPcid)) { + promises.AppendElement(dom::RTCStatsReportPromise::CreateAndResolve( + MakeUnique<dom::RTCStatsReportInternal>(report), __func__)); + } + } + } + + auto UnwrapUniquePtrs = [](dom::RTCStatsReportPromise::AllSettledPromiseType:: + ResolveOrRejectValue&& aResult) { + nsTArray<dom::RTCStatsReportInternal> reports; + MOZ_RELEASE_ASSERT(aResult.IsResolve(), "AllSettled should never reject!"); + for (auto& reportResult : aResult.ResolveValue()) { + if (reportResult.IsResolve()) { + reports.AppendElement(*reportResult.ResolveValue()); + } + } + return PWebrtcGlobalParent::GetStatsPromise::CreateAndResolve( + std::move(reports), __func__); + }; + + return dom::RTCStatsReportPromise::AllSettled( + GetMainThreadSerialEventTarget(), promises) + ->Then(GetMainThreadSerialEventTarget(), __func__, + std::move(UnwrapUniquePtrs)); +} + +static std::map<int32_t, dom::Sequence<nsString>>& GetWebrtcGlobalLogStash() { + static StaticAutoPtr<std::map<int32_t, dom::Sequence<nsString>>> sStash; + if (!sStash) { + sStash = new std::map<int32_t, dom::Sequence<nsString>>(); + ClearOnShutdown(&sStash); + } + return *sStash; +} + +static void ClearLongTermStats() { + if (!NS_IsMainThread()) { + MOZ_ASSERT(NS_IsMainThread()); + return; + } + + GetWebrtcGlobalStatsStash().Clear(); + if (XRE_IsParentProcess()) { + WebrtcGlobalStatsHistory::Clear(); + } + if (auto* ctx = GetPeerConnectionCtx()) { + ctx->ClearClosedStats(); + } +} + +void WebrtcGlobalInformation::ClearAllStats(const GlobalObject& aGlobal) { + if (!NS_IsMainThread()) { + return; + } + + // Chrome-only API + MOZ_ASSERT(XRE_IsParentProcess()); + + if (!WebrtcContentParents::Empty()) { + // Pass on the request to any content process based PeerConnections. + for (const auto& cp : WebrtcContentParents::GetAll()) { + Unused << cp->SendClearStats(); + } + } + + // Flush the history for the chrome process + ClearLongTermStats(); +} + +void WebrtcGlobalInformation::GetStatsHistoryPcIds( + const GlobalObject& aGlobal, + WebrtcGlobalStatisticsHistoryPcIdsCallback& aPcIdsCallback, + ErrorResult& aRv) { + if (!NS_IsMainThread()) { + aRv.Throw(NS_ERROR_NOT_SAME_THREAD); + return; + } + + MOZ_ASSERT(XRE_IsParentProcess()); + + IgnoredErrorResult rv; + aPcIdsCallback.Call(WebrtcGlobalStatsHistory::PcIds(), rv); + aRv = NS_OK; +} + +void WebrtcGlobalInformation::GetStatsHistorySince( + const GlobalObject& aGlobal, + WebrtcGlobalStatisticsHistoryCallback& aStatsCallback, + const nsAString& pcIdFilter, const Optional<DOMHighResTimeStamp>& aAfter, + const Optional<DOMHighResTimeStamp>& aSdpAfter, ErrorResult& aRv) { + if (!NS_IsMainThread()) { + aRv.Throw(NS_ERROR_NOT_SAME_THREAD); + return; + } + + MOZ_ASSERT(XRE_IsParentProcess()); + + WebrtcGlobalStatisticsReport history; + + auto statsAfter = aAfter.WasPassed() ? Some(aAfter.Value()) : Nothing(); + auto sdpAfter = aSdpAfter.WasPassed() ? Some(aSdpAfter.Value()) : Nothing(); + + WebrtcGlobalStatsHistory::GetHistory(pcIdFilter).apply([&](auto& hist) { + if (!history.mReports.AppendElements(hist->Since(statsAfter), fallible)) { + mozalloc_handle_oom(0); + } + if (!history.mSdpHistories.AppendElement(hist->SdpSince(sdpAfter), + fallible)) { + mozalloc_handle_oom(0); + } + }); + + IgnoredErrorResult rv; + aStatsCallback.Call(history, rv); + aRv = NS_OK; +} + +using StatsPromiseArray = + nsTArray<RefPtr<PWebrtcGlobalParent::GetStatsPromise>>; + +void WebrtcGlobalInformation::GatherHistory() { + const nsString emptyFilter; + if (!NS_IsMainThread()) { + MOZ_ASSERT(NS_IsMainThread()); + return; + } + + MOZ_ASSERT(XRE_IsParentProcess()); + using StatsPromise = PWebrtcGlobalParent::GetStatsPromise; + auto resolveThenAppendStatsHistory = [](RefPtr<StatsPromise>&& promise) { + auto AppendStatsHistory = [](StatsPromise::ResolveOrRejectValue&& result) { + if (result.IsReject()) { + return; + } + for (const auto& report : result.ResolveValue()) { + WebrtcGlobalStatsHistory::Record( + MakeUnique<RTCStatsReportInternal>(report)); + } + }; + promise->Then(GetMainThreadSerialEventTarget(), __func__, + std::move(AppendStatsHistory)); + }; + for (const auto& cp : WebrtcContentParents::GetAll()) { + resolveThenAppendStatsHistory(cp->SendGetStats(emptyFilter)); + } + resolveThenAppendStatsHistory(GetStatsPromiseForThisProcess(emptyFilter)); +} + +void WebrtcGlobalInformation::GetAllStats( + const GlobalObject& aGlobal, WebrtcGlobalStatisticsCallback& aStatsCallback, + const Optional<nsAString>& aPcIdFilter, ErrorResult& aRv) { + if (!NS_IsMainThread()) { + aRv.Throw(NS_ERROR_NOT_SAME_THREAD); + return; + } + + MOZ_ASSERT(XRE_IsParentProcess()); + + StatsPromiseArray statsPromises; + + nsString filter; + if (aPcIdFilter.WasPassed()) { + filter = aPcIdFilter.Value(); + } + + for (const auto& cp : WebrtcContentParents::GetAll()) { + statsPromises.AppendElement(cp->SendGetStats(filter)); + } + + // Stats from this (the parent) process. How long do we keep supporting this? + statsPromises.AppendElement(GetStatsPromiseForThisProcess(filter)); + + // CallbackObject does not support threadsafe refcounting, and must be + // used and destroyed on main. + StatsRequestCallback callbackHandle( + new nsMainThreadPtrHolder<WebrtcGlobalStatisticsCallback>( + "WebrtcGlobalStatisticsCallback", &aStatsCallback)); + + auto FlattenThenStashThenCallback = + [callbackHandle, + filter](PWebrtcGlobalParent::GetStatsPromise::AllSettledPromiseType:: + ResolveOrRejectValue&& aResult) MOZ_CAN_RUN_SCRIPT_BOUNDARY { + std::set<nsString> pcids; + WebrtcGlobalStatisticsReport flattened; + MOZ_RELEASE_ASSERT(aResult.IsResolve(), + "AllSettled should never reject!"); + // Flatten stats from content processes and parent process. + // The stats from the parent process (which will come last) might + // contain some stale content-process stats, so skip those. + for (auto& processResult : aResult.ResolveValue()) { + // TODO: Report rejection on individual content processes someday? + if (processResult.IsResolve()) { + for (auto& pcStats : processResult.ResolveValue()) { + if (!pcids.count(pcStats.mPcid)) { + pcids.insert(pcStats.mPcid); + if (!flattened.mReports.AppendElement(std::move(pcStats), + fallible)) { + mozalloc_handle_oom(0); + } + } + } + } + } + + if (filter.IsEmpty()) { + // Unfiltered is simple; the flattened result becomes the new stash. + GetWebrtcGlobalStatsStash() = flattened.mReports; + } else if (!flattened.mReports.IsEmpty()) { + // Update our stash with the single result. + MOZ_ASSERT(flattened.mReports.Length() == 1); + StashStats(flattened.mReports[0]); + } + + IgnoredErrorResult rv; + callbackHandle->Call(flattened, rv); + }; + + PWebrtcGlobalParent::GetStatsPromise::AllSettled( + GetMainThreadSerialEventTarget(), statsPromises) + ->Then(GetMainThreadSerialEventTarget(), __func__, + std::move(FlattenThenStashThenCallback)); + + aRv = NS_OK; +} + +static RefPtr<PWebrtcGlobalParent::GetLogPromise> GetLogPromise() { + PeerConnectionCtx* ctx = GetPeerConnectionCtx(); + if (!ctx) { + // This process has never created a PeerConnection, so no ICE logging. + return PWebrtcGlobalParent::GetLogPromise::CreateAndResolve( + Sequence<nsString>(), __func__); + } + + nsresult rv; + nsCOMPtr<nsISerialEventTarget> stsThread = + do_GetService(NS_SOCKETTRANSPORTSERVICE_CONTRACTID, &rv); + + if (NS_WARN_IF(NS_FAILED(rv) || !stsThread)) { + return PWebrtcGlobalParent::GetLogPromise::CreateAndResolve( + Sequence<nsString>(), __func__); + } + + RefPtr<MediaTransportHandler> transportHandler = ctx->GetTransportHandler(); + + auto AddMarkers = + [](MediaTransportHandler::IceLogPromise::ResolveOrRejectValue&& aValue) { + nsString pid; + pid.AppendInt(getpid()); + Sequence<nsString> logs; + if (aValue.IsResolve() && !aValue.ResolveValue().IsEmpty()) { + bool ok = logs.AppendElement( + u"+++++++ BEGIN (process id "_ns + pid + u") ++++++++"_ns, + fallible); + ok &= + !!logs.AppendElements(std::move(aValue.ResolveValue()), fallible); + ok &= !!logs.AppendElement( + u"+++++++ END (process id "_ns + pid + u") ++++++++"_ns, + fallible); + if (!ok) { + mozalloc_handle_oom(0); + } + } + return PWebrtcGlobalParent::GetLogPromise::CreateAndResolve( + std::move(logs), __func__); + }; + + return transportHandler->GetIceLog(nsCString()) + ->Then(GetMainThreadSerialEventTarget(), __func__, std::move(AddMarkers)); +} + +static nsresult RunLogClear() { + PeerConnectionCtx* ctx = GetPeerConnectionCtx(); + if (!ctx) { + // This process has never created a PeerConnection, so no ICE logging. + return NS_OK; + } + + nsresult rv; + nsCOMPtr<nsISerialEventTarget> stsThread = + do_GetService(NS_SOCKETTRANSPORTSERVICE_CONTRACTID, &rv); + + if (NS_FAILED(rv)) { + return rv; + } + if (!stsThread) { + return NS_ERROR_FAILURE; + } + + RefPtr<MediaTransportHandler> transportHandler = ctx->GetTransportHandler(); + + return RUN_ON_THREAD( + stsThread, + WrapRunnable(transportHandler, &MediaTransportHandler::ClearIceLog), + NS_DISPATCH_NORMAL); +} + +void WebrtcGlobalInformation::ClearLogging(const GlobalObject& aGlobal) { + if (!NS_IsMainThread()) { + return; + } + + // Chrome-only API + MOZ_ASSERT(XRE_IsParentProcess()); + GetWebrtcGlobalLogStash().clear(); + + if (!WebrtcContentParents::Empty()) { + // Clear content process signaling logs + for (const auto& cp : WebrtcContentParents::GetAll()) { + Unused << cp->SendClearLog(); + } + } + + // Clear chrome process signaling logs + Unused << RunLogClear(); +} + +static RefPtr<GenericPromise> UpdateLogStash() { + nsTArray<RefPtr<GenericPromise>> logPromises; + MOZ_ASSERT(XRE_IsParentProcess()); + for (const auto& cp : WebrtcContentParents::GetAll()) { + auto StashLog = + [id = cp->Id() * 2 /* Make sure 1 isn't used */]( + PWebrtcGlobalParent::GetLogPromise::ResolveOrRejectValue&& aValue) { + if (aValue.IsResolve() && !aValue.ResolveValue().IsEmpty()) { + GetWebrtcGlobalLogStash()[id] = aValue.ResolveValue(); + } + return GenericPromise::CreateAndResolve(true, __func__); + }; + logPromises.AppendElement(cp->SendGetLog()->Then( + GetMainThreadSerialEventTarget(), __func__, std::move(StashLog))); + } + + // Get ICE logging for this (the parent) process. How long do we support this? + logPromises.AppendElement(GetLogPromise()->Then( + GetMainThreadSerialEventTarget(), __func__, + [](PWebrtcGlobalParent::GetLogPromise::ResolveOrRejectValue&& aValue) { + if (aValue.IsResolve()) { + GetWebrtcGlobalLogStash()[1] = aValue.ResolveValue(); + } + return GenericPromise::CreateAndResolve(true, __func__); + })); + + return GenericPromise::AllSettled(GetMainThreadSerialEventTarget(), + logPromises) + ->Then(GetMainThreadSerialEventTarget(), __func__, + [](GenericPromise::AllSettledPromiseType::ResolveOrRejectValue&& + aValue) { + // We don't care about the value, since we're just going to copy + // what is in the stash. This ignores failures too, which is what + // we want. + return GenericPromise::CreateAndResolve(true, __func__); + }); +} + +void WebrtcGlobalInformation::GetLogging( + const GlobalObject& aGlobal, const nsAString& aPattern, + WebrtcGlobalLoggingCallback& aLoggingCallback, ErrorResult& aRv) { + if (!NS_IsMainThread()) { + aRv.Throw(NS_ERROR_NOT_SAME_THREAD); + return; + } + + MOZ_ASSERT(XRE_IsParentProcess()); + + nsAutoString pattern(aPattern); + + // CallbackObject does not support threadsafe refcounting, and must be + // destroyed on main. + LogRequestCallback callbackHandle( + new nsMainThreadPtrHolder<WebrtcGlobalLoggingCallback>( + "WebrtcGlobalLoggingCallback", &aLoggingCallback)); + + auto FilterThenCallback = + [pattern, callbackHandle](GenericPromise::ResolveOrRejectValue&& aValue) + MOZ_CAN_RUN_SCRIPT_BOUNDARY { + dom::Sequence<nsString> flattened; + for (const auto& [id, log] : GetWebrtcGlobalLogStash()) { + (void)id; + for (const auto& line : log) { + if (pattern.IsEmpty() || (line.Find(pattern) != kNotFound)) { + if (!flattened.AppendElement(line, fallible)) { + mozalloc_handle_oom(0); + } + } + } + } + IgnoredErrorResult rv; + callbackHandle->Call(flattened, rv); + }; + + UpdateLogStash()->Then(GetMainThreadSerialEventTarget(), __func__, + std::move(FilterThenCallback)); + aRv = NS_OK; +} + +static int32_t sLastSetLevel = 0; +static bool sLastAECDebug = false; +static Maybe<nsCString> sAecDebugLogDir; + +void WebrtcGlobalInformation::SetDebugLevel(const GlobalObject& aGlobal, + int32_t aLevel) { + if (aLevel) { + StartWebRtcLog(mozilla::LogLevel(aLevel)); + } else { + StopWebRtcLog(); + } + sLastSetLevel = aLevel; + + for (const auto& cp : WebrtcContentParents::GetAll()) { + Unused << cp->SendSetDebugMode(aLevel); + } +} + +int32_t WebrtcGlobalInformation::DebugLevel(const GlobalObject& aGlobal) { + return sLastSetLevel; +} + +void WebrtcGlobalInformation::SetAecDebug(const GlobalObject& aGlobal, + bool aEnable) { + if (aEnable) { + sAecDebugLogDir = Some(StartAecLog()); + } else { + StopAecLog(); + } + + sLastAECDebug = aEnable; + + for (const auto& cp : WebrtcContentParents::GetAll()) { + Unused << cp->SendSetAecLogging(aEnable); + } +} + +bool WebrtcGlobalInformation::AecDebug(const GlobalObject& aGlobal) { + return sLastAECDebug; +} + +void WebrtcGlobalInformation::GetAecDebugLogDir(const GlobalObject& aGlobal, + nsAString& aDir) { + aDir = NS_ConvertASCIItoUTF16(sAecDebugLogDir.valueOr(""_ns)); +} + +/*static*/ +void WebrtcGlobalInformation::StashStats( + const dom::RTCStatsReportInternal& aReport) { + // Remove previous report, if present + // TODO: Make this a map instead of an array? + for (size_t i = 0; i < GetWebrtcGlobalStatsStash().Length();) { + auto& pcStats = GetWebrtcGlobalStatsStash()[i]; + if (pcStats.mPcid == aReport.mPcid) { + GetWebrtcGlobalStatsStash().RemoveElementAt(i); + break; + } + ++i; + } + // Stash final stats + GetWebrtcGlobalStatsStash().AppendElement(aReport); +} + +void WebrtcGlobalInformation::AdjustTimerReferences( + PcTrackingUpdate&& aUpdate) { + static StaticRefPtr<nsITimer> sHistoryTimer; + static StaticAutoPtr<nsTHashSet<nsString>> sPcids; + + MOZ_ASSERT(NS_IsMainThread()); + + auto HandleAdd = [&](nsString&& aPcid, bool aIsLongTermStatsDisabled) { + if (!sPcids) { + sPcids = new nsTHashSet<nsString>(); + ClearOnShutdown(&sPcids); + } + sPcids->EnsureInserted(aPcid); + // Reserve a stats history + WebrtcGlobalStatsHistory::InitHistory(nsString(aPcid), + aIsLongTermStatsDisabled); + if (!sHistoryTimer) { + sHistoryTimer = NS_NewTimer(GetMainThreadSerialEventTarget()); + if (sHistoryTimer) { + sHistoryTimer->InitWithNamedFuncCallback( + [](nsITimer* aTimer, void* aClosure) { + if (WebrtcGlobalStatsHistory::Pref::Enabled()) { + WebrtcGlobalInformation::GatherHistory(); + } + }, + nullptr, WebrtcGlobalStatsHistory::Pref::PollIntervalMs(), + nsITimer::TYPE_REPEATING_SLACK, + "WebrtcGlobalInformation::GatherHistory"); + } + ClearOnShutdown(&sHistoryTimer); + } + }; + + auto HandleRemove = [&](const nsString& aRemoved) { + WebrtcGlobalStatsHistory::CloseHistory(nsString(aRemoved)); + if (!sPcids || !sPcids->Count()) { + return; + } + if (!sPcids->Contains(aRemoved)) { + return; + } + sPcids->Remove(aRemoved); + if (!sPcids->Count() && sHistoryTimer) { + sHistoryTimer->Cancel(); + sHistoryTimer = nullptr; + } + }; + + switch (aUpdate.Type()) { + case PcTrackingUpdate::Type::Add: { + HandleAdd(std::move(aUpdate.mPcid), + aUpdate.mLongTermStatsDisabled.valueOrFrom([&]() { + MOZ_ASSERT(aUpdate.mLongTermStatsDisabled.isNothing()); + return true; + })); + return; + } + case PcTrackingUpdate::Type::Remove: { + HandleRemove(aUpdate.mPcid); + return; + } + default: { + MOZ_ASSERT(false, "Invalid PcCount operation"); + } + } +} + +WebrtcGlobalParent* WebrtcGlobalParent::Alloc() { + return WebrtcContentParents::Alloc(); +} + +bool WebrtcGlobalParent::Dealloc(WebrtcGlobalParent* aActor) { + WebrtcContentParents::Dealloc(aActor); + return true; +} + +void WebrtcGlobalParent::ActorDestroy(ActorDestroyReason aWhy) { + mShutdown = true; + for (const auto& pcId : mPcids) { + using Update = WebrtcGlobalInformation::PcTrackingUpdate; + auto update = Update::Remove(nsString(pcId)); + WebrtcGlobalInformation::PeerConnectionTracking(update); + } +} + +mozilla::ipc::IPCResult WebrtcGlobalParent::Recv__delete__() { + return IPC_OK(); +} + +mozilla::ipc::IPCResult WebrtcGlobalParent::RecvPeerConnectionCreated( + const nsAString& aPcId, const bool& aIsLongTermStatsDisabled) { + if (mShutdown) { + return IPC_OK(); + } + mPcids.EnsureInserted(aPcId); + using Update = WebrtcGlobalInformation::PcTrackingUpdate; + auto update = Update::Add(nsString(aPcId), aIsLongTermStatsDisabled); + WebrtcGlobalInformation::PeerConnectionTracking(update); + return IPC_OK(); +} + +mozilla::ipc::IPCResult WebrtcGlobalParent::RecvPeerConnectionDestroyed( + const nsAString& aPcId) { + mPcids.EnsureRemoved(aPcId); + using Update = WebrtcGlobalInformation::PcTrackingUpdate; + auto update = Update::Remove(nsString(aPcId)); + WebrtcGlobalStatsHistory::CloseHistory(aPcId); + WebrtcGlobalInformation::PeerConnectionTracking(update); + return IPC_OK(); +} + +mozilla::ipc::IPCResult WebrtcGlobalParent::RecvPeerConnectionFinalStats( + const RTCStatsReportInternal& aFinalStats) { + auto finalStats = MakeUnique<RTCStatsReportInternal>(aFinalStats); + WebrtcGlobalStatsHistory::Record(std::move(finalStats)); + WebrtcGlobalStatsHistory::CloseHistory(aFinalStats.mPcid); + return IPC_OK(); +} + +MOZ_IMPLICIT WebrtcGlobalParent::WebrtcGlobalParent() : mShutdown(false) { + MOZ_COUNT_CTOR(WebrtcGlobalParent); +} + +MOZ_IMPLICIT WebrtcGlobalParent::~WebrtcGlobalParent() { + MOZ_COUNT_DTOR(WebrtcGlobalParent); +} + +mozilla::ipc::IPCResult WebrtcGlobalChild::RecvGetStats( + const nsAString& aPcIdFilter, GetStatsResolver&& aResolve) { + if (!mShutdown) { + GetStatsPromiseForThisProcess(aPcIdFilter) + ->Then( + GetMainThreadSerialEventTarget(), __func__, + [resolve = std::move(aResolve)]( + nsTArray<dom::RTCStatsReportInternal>&& aReports) { + resolve(std::move(aReports)); + }, + []() { MOZ_CRASH(); }); + return IPC_OK(); + } + + aResolve(nsTArray<RTCStatsReportInternal>()); + return IPC_OK(); +} + +mozilla::ipc::IPCResult WebrtcGlobalChild::RecvClearStats() { + if (mShutdown) { + return IPC_OK(); + } + + ClearLongTermStats(); + return IPC_OK(); +} + +mozilla::ipc::IPCResult WebrtcGlobalChild::RecvGetLog( + GetLogResolver&& aResolve) { + if (mShutdown) { + aResolve(Sequence<nsString>()); + return IPC_OK(); + } + + GetLogPromise()->Then( + GetMainThreadSerialEventTarget(), __func__, + [aResolve = std::move(aResolve)]( + PWebrtcGlobalParent::GetLogPromise::ResolveOrRejectValue&& aValue) { + if (aValue.IsResolve()) { + aResolve(aValue.ResolveValue()); + } else { + aResolve(Sequence<nsString>()); + } + }); + + return IPC_OK(); +} + +mozilla::ipc::IPCResult WebrtcGlobalChild::RecvClearLog() { + if (mShutdown) { + return IPC_OK(); + } + + RunLogClear(); + return IPC_OK(); +} + +mozilla::ipc::IPCResult WebrtcGlobalChild::RecvSetAecLogging( + const bool& aEnable) { + if (!mShutdown) { + if (aEnable) { + StartAecLog(); + } else { + StopAecLog(); + } + } + return IPC_OK(); +} + +mozilla::ipc::IPCResult WebrtcGlobalChild::RecvSetDebugMode(const int& aLevel) { + if (!mShutdown) { + if (aLevel) { + StartWebRtcLog(mozilla::LogLevel(aLevel)); + } else { + StopWebRtcLog(); + } + } + return IPC_OK(); +} + +WebrtcGlobalChild* WebrtcGlobalChild::GetOrSet( + const Maybe<WebrtcGlobalChild*>& aChild) { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(XRE_IsContentProcess()); + static WebrtcGlobalChild* sChild; + if (!sChild && !aChild) { + sChild = static_cast<WebrtcGlobalChild*>( + ContentChild::GetSingleton()->SendPWebrtcGlobalConstructor()); + } + aChild.apply([](auto* child) { sChild = child; }); + return sChild; +} + +WebrtcGlobalChild* WebrtcGlobalChild::Get() { return GetOrSet(Nothing()); } + +void WebrtcGlobalChild::ActorDestroy(ActorDestroyReason aWhy) { + mShutdown = true; +} + +MOZ_IMPLICIT WebrtcGlobalChild::WebrtcGlobalChild() : mShutdown(false) { + MOZ_COUNT_CTOR(WebrtcGlobalChild); +} + +MOZ_IMPLICIT WebrtcGlobalChild::~WebrtcGlobalChild() { + MOZ_COUNT_DTOR(WebrtcGlobalChild); + GetOrSet(Some(nullptr)); +} + +} // namespace mozilla::dom diff --git a/dom/media/webrtc/jsapi/WebrtcGlobalInformation.h b/dom/media/webrtc/jsapi/WebrtcGlobalInformation.h new file mode 100644 index 0000000000..d43013bb43 --- /dev/null +++ b/dom/media/webrtc/jsapi/WebrtcGlobalInformation.h @@ -0,0 +1,102 @@ +/* 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/. */ + +#ifndef _WEBRTC_GLOBAL_INFORMATION_H_ +#define _WEBRTC_GLOBAL_INFORMATION_H_ + +#include <tuple> +#include "mozilla/dom/WebrtcGlobalInformationBinding.h" +#include "nsString.h" +#include "mozilla/dom/BindingDeclarations.h" // for Optional +#include "nsDOMNavigationTiming.h" +#include "WebrtcGlobalStatsHistory.h" + +namespace mozilla { +class PeerConnectionImpl; +class ErrorResult; + +namespace dom { + +class GlobalObject; +class WebrtcGlobalStatisticsCallback; +class WebrtcGlobalStatisticsHistoryPcIdsCallback; +class WebrtcGlobalLoggingCallback; +struct RTCStatsReportInternal; + +class WebrtcGlobalInformation { + public: + MOZ_CAN_RUN_SCRIPT + static void GetAllStats(const GlobalObject& aGlobal, + WebrtcGlobalStatisticsCallback& aStatsCallback, + const Optional<nsAString>& aPcIdFilter, + ErrorResult& aRv); + + MOZ_CAN_RUN_SCRIPT + static void GetStatsHistoryPcIds( + const GlobalObject& aGlobal, + WebrtcGlobalStatisticsHistoryPcIdsCallback& aPcIdsCallback, + ErrorResult& aRv); + + MOZ_CAN_RUN_SCRIPT + static void GetStatsHistorySince( + const GlobalObject& aGlobal, + WebrtcGlobalStatisticsHistoryCallback& aStatsCallback, + const nsAString& aPcIdFilter, const Optional<DOMHighResTimeStamp>& aAfter, + const Optional<DOMHighResTimeStamp>& aSdpAfter, ErrorResult& aRv); + + static void GatherHistory(); + + static void ClearAllStats(const GlobalObject& aGlobal); + + MOZ_CAN_RUN_SCRIPT + static void GetLogging(const GlobalObject& aGlobal, const nsAString& aPattern, + WebrtcGlobalLoggingCallback& aLoggingCallback, + ErrorResult& aRv); + + static void ClearLogging(const GlobalObject& aGlobal); + + static void SetDebugLevel(const GlobalObject& aGlobal, int32_t aLevel); + static int32_t DebugLevel(const GlobalObject& aGlobal); + + static void SetAecDebug(const GlobalObject& aGlobal, bool aEnable); + static bool AecDebug(const GlobalObject& aGlobal); + static void GetAecDebugLogDir(const GlobalObject& aGlobal, nsAString& aDir); + + static void StashStats(const RTCStatsReportInternal& aReport); + + WebrtcGlobalInformation() = delete; + WebrtcGlobalInformation(const WebrtcGlobalInformation& aOrig) = delete; + WebrtcGlobalInformation& operator=(const WebrtcGlobalInformation& aRhs) = + delete; + + struct PcTrackingUpdate { + static PcTrackingUpdate Add(const nsString& aPcid, + const bool& aLongTermStatsDisabled) { + return PcTrackingUpdate{aPcid, Some(aLongTermStatsDisabled)}; + } + static PcTrackingUpdate Remove(const nsString& aPcid) { + return PcTrackingUpdate{aPcid, Nothing()}; + } + nsString mPcid; + Maybe<bool> mLongTermStatsDisabled; + enum class Type { + Add, + Remove, + }; + Type Type() const { + return mLongTermStatsDisabled ? Type::Add : Type::Remove; + } + }; + static void PeerConnectionTracking(PcTrackingUpdate& aUpdate) { + AdjustTimerReferences(std::move(aUpdate)); + } + + private: + static void AdjustTimerReferences(PcTrackingUpdate&& aUpdate); +}; + +} // namespace dom +} // namespace mozilla + +#endif // _WEBRTC_GLOBAL_INFORMATION_H_ diff --git a/dom/media/webrtc/jsapi/WebrtcGlobalParent.h b/dom/media/webrtc/jsapi/WebrtcGlobalParent.h new file mode 100644 index 0000000000..8372c4182f --- /dev/null +++ b/dom/media/webrtc/jsapi/WebrtcGlobalParent.h @@ -0,0 +1,52 @@ +/* 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/. */ + +#ifndef _WEBRTC_GLOBAL_PARENT_H_ +#define _WEBRTC_GLOBAL_PARENT_H_ + +#include "mozilla/dom/PWebrtcGlobalParent.h" +#include "mozilla/dom/BindingDeclarations.h" +#include "nsISupportsImpl.h" + +namespace mozilla::dom { + +class WebrtcParents; + +class WebrtcGlobalParent : public PWebrtcGlobalParent { + friend class ContentParent; + friend class WebrtcGlobalInformation; + friend class WebrtcContentParents; + + bool mShutdown; + nsTHashSet<nsString> mPcids; + + MOZ_IMPLICIT WebrtcGlobalParent(); + + static WebrtcGlobalParent* Alloc(); + static bool Dealloc(WebrtcGlobalParent* aActor); + + virtual void ActorDestroy(ActorDestroyReason aWhy) override; + virtual mozilla::ipc::IPCResult Recv__delete__() override; + // Notification that a PeerConnection exists, and stats polling can begin + // if it hasn't already begun due to a previously created PeerConnection. + virtual mozilla::ipc::IPCResult RecvPeerConnectionCreated( + const nsAString& aPcId, const bool& aIsLongTermStatsDisabled) override; + // Notification that a PeerConnection no longer exists, and stats polling + // can end if there are no other PeerConnections. + virtual mozilla::ipc::IPCResult RecvPeerConnectionDestroyed( + const nsAString& aPcid) override; + // Ditto but we have final stats + virtual mozilla::ipc::IPCResult RecvPeerConnectionFinalStats( + const RTCStatsReportInternal& aFinalStats) override; + virtual ~WebrtcGlobalParent(); + + public: + NS_INLINE_DECL_REFCOUNTING(WebrtcGlobalParent) + + bool IsActive() { return !mShutdown; } +}; + +} // namespace mozilla::dom + +#endif // _WEBRTC_GLOBAL_PARENT_H_ diff --git a/dom/media/webrtc/jsapi/WebrtcGlobalStatsHistory.cpp b/dom/media/webrtc/jsapi/WebrtcGlobalStatsHistory.cpp new file mode 100644 index 0000000000..1d576b5dca --- /dev/null +++ b/dom/media/webrtc/jsapi/WebrtcGlobalStatsHistory.cpp @@ -0,0 +1,282 @@ +/* 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 "WebrtcGlobalStatsHistory.h" +#include <memory> + +#include "domstubs.h" +#include "mozilla/LinkedList.h" +#include "mozilla/dom/BindingUtils.h" +#include "mozilla/dom/RTCStatsReportBinding.h" // for RTCStatsReportInternal +#include "mozilla/ClearOnShutdown.h" +#include "mozilla/StaticPrefs_media.h" +#include "mozilla/fallible.h" +#include "mozilla/mozalloc_oom.h" +#include "nsDOMNavigationTiming.h" + +namespace mozilla::dom { + +constexpr auto SEC_TO_MS(const DOMHighResTimeStamp sec) -> DOMHighResTimeStamp { + return sec * 1000.0; +} + +constexpr auto MIN_TO_MS(const DOMHighResTimeStamp min) -> DOMHighResTimeStamp { + return SEC_TO_MS(min * 60.0); +} + +// Prefs +auto WebrtcGlobalStatsHistory::Pref::Enabled() -> bool { + return mozilla::StaticPrefs::media_aboutwebrtc_hist_enabled(); +} + +auto WebrtcGlobalStatsHistory::Pref::PollIntervalMs() -> uint32_t { + return mozilla::StaticPrefs::media_aboutwebrtc_hist_poll_interval_ms(); +} + +auto WebrtcGlobalStatsHistory::Pref::StorageWindowS() -> uint32_t { + return mozilla::StaticPrefs::media_aboutwebrtc_hist_storage_window_s(); +} + +auto WebrtcGlobalStatsHistory::Pref::PruneAfterM() -> uint32_t { + return mozilla::StaticPrefs::media_aboutwebrtc_hist_prune_after_m(); +} + +auto WebrtcGlobalStatsHistory::Pref::ClosedStatsToRetain() -> uint32_t { + return mozilla::StaticPrefs::media_aboutwebrtc_hist_closed_stats_to_retain(); +} + +auto WebrtcGlobalStatsHistory::Get() -> WebrtcGlobalStatsHistory::StatsMap& { + static StaticAutoPtr<StatsMap> sHist; + if (!sHist) { + sHist = new StatsMap(); + ClearOnShutdown(&sHist); + } + return *sHist; +} + +auto WebrtcGlobalStatsHistory::Entry::ReportElement::Timestamp() const + -> DOMHighResTimeStamp { + return report->mTimestamp; +} + +auto WebrtcGlobalStatsHistory::Entry::SdpElement::Timestamp() const + -> DOMHighResTimeStamp { + return sdp.mTimestamp; +} + +auto WebrtcGlobalStatsHistory::Entry::MakeReportElement( + UniquePtr<RTCStatsReportInternal> aReport) + -> WebrtcGlobalStatsHistory::Entry::ReportElement* { + auto* elem = new ReportElement(); + elem->report = std::move(aReport); + // We don't want to store a copy of the SDP history with each stats entry. + // SDP History is stored seperately, see MakeSdpElements. + elem->report->mSdpHistory.Clear(); + return elem; +} + +auto WebrtcGlobalStatsHistory::Entry::MakeSdpElementsSince( + Sequence<RTCSdpHistoryEntryInternal>&& aSdpHistory, + const Maybe<DOMHighResTimeStamp>& aSdpAfter) + -> AutoCleanLinkedList<WebrtcGlobalStatsHistory::Entry::SdpElement> { + AutoCleanLinkedList<WebrtcGlobalStatsHistory::Entry::SdpElement> result; + for (auto& sdpHist : aSdpHistory) { + if (!aSdpAfter || aSdpAfter.value() < sdpHist.mTimestamp) { + auto* element = new SdpElement(); + element->sdp = sdpHist; + result.insertBack(element); + } + } + return result; +} + +template <typename T> +auto FindFirstEntryAfter(const T* first, + const Maybe<DOMHighResTimeStamp>& aAfter) -> const T* { + const auto* current = first; + while (aAfter && current && current->Timestamp() <= aAfter.value()) { + current = current->getNext(); + } + return current; +} + +template <typename T> +auto CountElementsToEndInclusive(const LinkedListElement<T>* elem) -> size_t { + size_t count = 0; + const auto* cursor = elem; + while (cursor && cursor->isInList()) { + count++; + cursor = cursor->getNext(); + } + return count; +} + +auto WebrtcGlobalStatsHistory::Entry::Since( + const Maybe<DOMHighResTimeStamp>& aAfter) const + -> nsTArray<RTCStatsReportInternal> { + nsTArray<RTCStatsReportInternal> results; + const auto* cursor = FindFirstEntryAfter(mReports.getFirst(), aAfter); + const auto count = CountElementsToEndInclusive(cursor); + if (!results.SetCapacity(count, fallible)) { + mozalloc_handle_oom(0); + } + while (cursor) { + results.AppendElement(RTCStatsReportInternal(*cursor->report)); + cursor = cursor->getNext(); + } + return results; +} + +auto WebrtcGlobalStatsHistory::Entry::SdpSince( + const Maybe<DOMHighResTimeStamp>& aAfter) const -> RTCSdpHistoryInternal { + RTCSdpHistoryInternal results; + results.mPcid = mPcid; + // If no timestamp was passed copy the entire history + const auto* cursor = FindFirstEntryAfter(mSdp.getFirst(), aAfter); + const auto count = CountElementsToEndInclusive(cursor); + if (!results.mSdpHistory.SetCapacity(count, fallible)) { + mozalloc_handle_oom(0); + } + while (cursor) { + if (!results.mSdpHistory.AppendElement( + RTCSdpHistoryEntryInternal(cursor->sdp), fallible)) { + mozalloc_handle_oom(0); + } + cursor = cursor->getNext(); + } + return results; +} + +auto WebrtcGlobalStatsHistory::Entry::Prune(const DOMHighResTimeStamp aBefore) + -> void { + // Clear everything in the case that we don't keep stats + if (mIsLongTermStatsDisabled) { + mReports.clear(); + } + // Clear everything before the cutoff + for (auto* element = mReports.getFirst(); + element && element->report->mTimestamp < aBefore; + element = mReports.getFirst()) { + delete mReports.popFirst(); + } + // I don't think we should prune SDPs but if we did it would look like this: + // Note: we always keep the most recent SDP +} + +auto WebrtcGlobalStatsHistory::InitHistory(const nsAString& aPcId, + const bool aIsLongTermStatsDisabled) + -> void { + MOZ_ASSERT(XRE_IsParentProcess()); + if (WebrtcGlobalStatsHistory::Get().MaybeGet(aPcId)) { + return; + } + WebrtcGlobalStatsHistory::Get().GetOrInsertNew(aPcId, nsString(aPcId), + aIsLongTermStatsDisabled); +}; + +auto WebrtcGlobalStatsHistory::Record(UniquePtr<RTCStatsReportInternal> aReport) + -> void { + MOZ_ASSERT(XRE_IsParentProcess()); + // Use the report timestamp as "now" for determining time depth + // based pruning. + const auto now = aReport->mTimestamp; + const auto earliest = now - SEC_TO_MS(Pref::StorageWindowS()); + + // Store closed state before moving the report + const auto closed = aReport->mClosed; + const auto pcId = aReport->mPcid; + + auto history = WebrtcGlobalStatsHistory::GetHistory(aReport->mPcid); + if (history && Pref::Enabled()) { + auto entry = history.value(); + // Remove expired entries + entry->Prune(earliest); + // Find new SDP entries + auto sdpAfter = Maybe<DOMHighResTimeStamp>(Nothing()); + if (auto* lastSdp = entry->mSdp.getLast(); lastSdp) { + sdpAfter = Some(lastSdp->Timestamp()); + } + entry->mSdp.extendBack( + Entry::MakeSdpElementsSince(std::move(aReport->mSdpHistory), sdpAfter)); + // Reports must be in ascending order by mTimestamp + const auto* latest = entry->mReports.getLast(); + // Maintain sorted order + if (!latest || latest->report->mTimestamp < aReport->mTimestamp) { + entry->mReports.insertBack(Entry::MakeReportElement(std::move(aReport))); + } + } + // Close the history if needed + if (closed) { + CloseHistory(pcId); + } +} + +auto WebrtcGlobalStatsHistory::CloseHistory(const nsAString& aPcId) -> void { + MOZ_ASSERT(XRE_IsParentProcess()); + auto maybeHist = WebrtcGlobalStatsHistory::Get().MaybeGet(aPcId); + if (!maybeHist) { + return; + } + { + auto&& hist = maybeHist.value(); + hist->mIsClosed = true; + + if (hist->mIsLongTermStatsDisabled) { + WebrtcGlobalStatsHistory::Get().Remove(aPcId); + return; + } + } + size_t remainingClosedStatsToRetain = + WebrtcGlobalStatsHistory::Pref::ClosedStatsToRetain(); + WebrtcGlobalStatsHistory::Get().RemoveIf([&](auto& iter) { + auto& entry = iter.Data(); + if (!entry->mIsClosed) { + return false; + } + if (entry->mIsLongTermStatsDisabled) { + return true; + } + if (remainingClosedStatsToRetain > 0) { + remainingClosedStatsToRetain -= 1; + return false; + } + return true; + }); +} + +auto WebrtcGlobalStatsHistory::Clear() -> void { + MOZ_ASSERT(XRE_IsParentProcess()); + WebrtcGlobalStatsHistory::Get().RemoveIf([](auto& aIter) { + // First clear all the closed histories. + if (aIter.Data()->mIsClosed) { + return true; + } + // For all remaining histories clear their stored reports + aIter.Data()->mReports.clear(); + // As an optimization we don't clear the SDP, because that would + // be reconstitued in the very next stats gathering polling period. + // Those are potentially large allocations which we can skip. + return false; + }); +} + +auto WebrtcGlobalStatsHistory::PcIds() -> dom::Sequence<nsString> { + MOZ_ASSERT(XRE_IsParentProcess()); + dom::Sequence<nsString> pcIds; + for (const auto& pcId : WebrtcGlobalStatsHistory::Get().Keys()) { + if (!pcIds.AppendElement(pcId, fallible)) { + mozalloc_handle_oom(0); + } + } + return pcIds; +} + +auto WebrtcGlobalStatsHistory::GetHistory(const nsAString& aPcId) + -> Maybe<RefPtr<Entry> > { + MOZ_ASSERT(XRE_IsParentProcess()); + const auto pcid = NS_ConvertUTF16toUTF8(aPcId); + + return WebrtcGlobalStatsHistory::Get().MaybeGet(aPcId); +} +} // namespace mozilla::dom diff --git a/dom/media/webrtc/jsapi/WebrtcGlobalStatsHistory.h b/dom/media/webrtc/jsapi/WebrtcGlobalStatsHistory.h new file mode 100644 index 0000000000..aa820e787d --- /dev/null +++ b/dom/media/webrtc/jsapi/WebrtcGlobalStatsHistory.h @@ -0,0 +1,88 @@ +/* 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/. */ + +#pragma once + +#include <memory> +#include "domstubs.h" +#include "mozilla/LinkedList.h" +#include "mozilla/UniquePtr.h" +#include "mozilla/dom/BindingDeclarations.h" +#include "mozilla/dom/DOMString.h" +#include "mozilla/dom/RTCStatsReportBinding.h" +#include "nsDOMNavigationTiming.h" +#include "nsHashKeys.h" +#include "nsTHashMap.h" + +namespace mozilla::dom { +class WebrtcGlobalStatisticsHistoryCallback; +struct RTCStatsReportInternal; + +struct WebrtcGlobalStatsHistory { + // History preferences + struct Pref { + static auto Enabled() -> bool; + static auto PollIntervalMs() -> uint32_t; + static auto StorageWindowS() -> uint32_t; + static auto PruneAfterM() -> uint32_t; + static auto ClosedStatsToRetain() -> uint32_t; + Pref() = delete; + ~Pref() = delete; + }; + + struct Entry { + NS_INLINE_DECL_THREADSAFE_REFCOUNTING(Entry) + // We need to wrap the report in an element + struct ReportElement : public LinkedListElement<ReportElement> { + UniquePtr<RTCStatsReportInternal> report; + auto Timestamp() const -> DOMHighResTimeStamp; + virtual ~ReportElement() = default; + }; + // And likewise for the SDP history + struct SdpElement : public LinkedListElement<SdpElement> { + RTCSdpHistoryEntryInternal sdp; + auto Timestamp() const -> DOMHighResTimeStamp; + virtual ~SdpElement() = default; + }; + + explicit Entry(const nsString& aPcid, const bool aIsLongTermStatsDisabled) + : mPcid(aPcid), mIsLongTermStatsDisabled(aIsLongTermStatsDisabled) {} + + nsString mPcid; + AutoCleanLinkedList<ReportElement> mReports; + AutoCleanLinkedList<SdpElement> mSdp; + bool mIsLongTermStatsDisabled; + bool mIsClosed = false; + + auto Since(const Maybe<DOMHighResTimeStamp>& aAfter) const + -> nsTArray<RTCStatsReportInternal>; + auto SdpSince(const Maybe<DOMHighResTimeStamp>& aAfter) const + -> RTCSdpHistoryInternal; + + static auto MakeReportElement(UniquePtr<RTCStatsReportInternal> aReport) + -> ReportElement*; + static auto MakeSdpElementsSince( + Sequence<RTCSdpHistoryEntryInternal>&& aSdpHistory, + const Maybe<DOMHighResTimeStamp>& aSdpAfter) + -> AutoCleanLinkedList<SdpElement>; + auto Prune(const DOMHighResTimeStamp aBefore) -> void; + + private: + virtual ~Entry() = default; + }; + using StatsMap = nsTHashMap<nsStringHashKey, RefPtr<Entry> >; + static auto InitHistory(const nsAString& aPcId, + const bool aIsLongTermStatsDisabled) -> void; + static auto Record(UniquePtr<RTCStatsReportInternal> aReport) -> void; + static auto CloseHistory(const nsAString& aPcId) -> void; + static auto GetHistory(const nsAString& aPcId) -> Maybe<RefPtr<Entry> >; + static auto Clear() -> void; + static auto PcIds() -> dom::Sequence<nsString>; + + WebrtcGlobalStatsHistory() = delete; + + private: + static auto Get() -> StatsMap&; +}; +} // namespace mozilla::dom diff --git a/dom/media/webrtc/jsapi/moz.build b/dom/media/webrtc/jsapi/moz.build new file mode 100644 index 0000000000..2c1dbe79f1 --- /dev/null +++ b/dom/media/webrtc/jsapi/moz.build @@ -0,0 +1,51 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# 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("/dom/media/webrtc/third_party_build/webrtc.mozbuild") + +LOCAL_INCLUDES += [ + "!/ipc/ipdl/_ipdlheaders", + "/dom/base", + "/dom/media", + "/dom/media/webrtc", + "/ipc/chromium/src", + "/media/webrtc", + "/netwerk/dns", # For nsDNSService2.h + "/third_party/libsrtp/src/include", + "/third_party/libwebrtc", + "/third_party/libwebrtc/third_party/abseil-cpp", +] + +UNIFIED_SOURCES += [ + "MediaTransportHandler.cpp", + "MediaTransportHandlerIPC.cpp", + "MediaTransportParent.cpp", + "PacketDumper.cpp", + "PeerConnectionCtx.cpp", + "PeerConnectionImpl.cpp", + "RemoteTrackSource.cpp", + "RTCDtlsTransport.cpp", + "RTCDTMFSender.cpp", + "RTCRtpReceiver.cpp", + "RTCRtpSender.cpp", + "RTCRtpTransceiver.cpp", + "RTCSctpTransport.cpp", + "RTCStatsIdGenerator.cpp", + "RTCStatsReport.cpp", + "WebrtcGlobalInformation.cpp", + "WebrtcGlobalStatsHistory.cpp", +] + +EXPORTS.mozilla.dom += [ + "RTCDtlsTransport.h", + "RTCDTMFSender.h", + "RTCRtpReceiver.h", + "RTCRtpSender.h", + "RTCRtpTransceiver.h", + "RTCSctpTransport.h", + "RTCStatsReport.h", +] + +FINAL_LIBRARY = "xul" |