RTCPeerConnection.h [plain text]
#pragma once
#if ENABLE(WEB_RTC)
#include "ActiveDOMObject.h"
#include "EventTarget.h"
#include "MediaEndpointConfiguration.h"
#include "MediaStream.h"
#include "RTCConfiguration.h"
#include "RTCDataChannel.h"
#include "RTCIceConnectionState.h"
#include "RTCIceGatheringState.h"
#include "RTCPeerConnectionState.h"
#include "RTCRtpTransceiver.h"
#include "RTCSignalingState.h"
#include <JavaScriptCore/Uint8Array.h>
#include <wtf/LoggerHelper.h>
namespace WebCore {
class MediaStream;
class MediaStreamTrack;
class PeerConnectionBackend;
class RTCController;
class RTCIceCandidate;
class RTCPeerConnectionErrorCallback;
class RTCSessionDescription;
class RTCStatsCallback;
struct RTCAnswerOptions;
struct RTCOfferOptions;
struct RTCRtpParameters;
struct RTCRtpTransceiverInit {
RTCRtpTransceiverDirection direction { RTCRtpTransceiverDirection::Sendrecv };
Vector<RefPtr<MediaStream>> streams;
};
class RTCPeerConnection final
: public RefCounted<RTCPeerConnection>
, public EventTargetWithInlineData
, public ActiveDOMObject
#if !RELEASE_LOG_DISABLED
, private LoggerHelper
#endif
{
WTF_MAKE_ISO_ALLOCATED(RTCPeerConnection);
public:
static Ref<RTCPeerConnection> create(ScriptExecutionContext&);
virtual ~RTCPeerConnection();
using DataChannelInit = RTCDataChannelInit;
ExceptionOr<void> initializeWith(Document&, RTCConfiguration&&);
struct CertificateParameters {
String name;
String hash;
String namedCurve;
Optional<uint32_t> modulusLength;
RefPtr<Uint8Array> publicExponent;
Optional<double> expires;
};
using AlgorithmIdentifier = Variant<JSC::Strong<JSC::JSObject>, String>;
static void generateCertificate(JSC::JSGlobalObject&, AlgorithmIdentifier&&, DOMPromiseDeferred<IDLInterface<RTCCertificate>>&&);
void queuedCreateOffer(RTCOfferOptions&&, PeerConnection::SessionDescriptionPromise&&);
void queuedCreateAnswer(RTCAnswerOptions&&, PeerConnection::SessionDescriptionPromise&&);
void queuedSetLocalDescription(RTCSessionDescription&, DOMPromiseDeferred<void>&&);
RefPtr<RTCSessionDescription> localDescription() const;
RefPtr<RTCSessionDescription> currentLocalDescription() const;
RefPtr<RTCSessionDescription> pendingLocalDescription() const;
void queuedSetRemoteDescription(RTCSessionDescription&, DOMPromiseDeferred<void>&&);
RefPtr<RTCSessionDescription> remoteDescription() const;
RefPtr<RTCSessionDescription> currentRemoteDescription() const;
RefPtr<RTCSessionDescription> pendingRemoteDescription() const;
void queuedAddIceCandidate(RTCIceCandidate*, DOMPromiseDeferred<void>&&);
RTCSignalingState signalingState() const { return m_signalingState; }
RTCIceGatheringState iceGatheringState() const { return m_iceGatheringState; }
RTCIceConnectionState iceConnectionState() const { return m_iceConnectionState; }
RTCPeerConnectionState connectionState() const { return m_connectionState; }
const RTCConfiguration& getConfiguration() const { return m_configuration; }
ExceptionOr<void> setConfiguration(RTCConfiguration&&);
void close();
bool isClosed() const { return m_connectionState == RTCPeerConnectionState::Closed; }
bool isStopped() const { return m_isStopped; }
void addInternalTransceiver(Ref<RTCRtpTransceiver>&& transceiver) { m_transceiverSet->append(WTFMove(transceiver)); }
Vector<std::reference_wrapper<RTCRtpSender>> getSenders() const;
Vector<std::reference_wrapper<RTCRtpReceiver>> getReceivers() const;
const Vector<RefPtr<RTCRtpTransceiver>>& getTransceivers() const;
const Vector<RefPtr<RTCRtpTransceiver>>& currentTransceivers() const { return m_transceiverSet->list(); }
ExceptionOr<Ref<RTCRtpSender>> addTrack(Ref<MediaStreamTrack>&&, const Vector<std::reference_wrapper<MediaStream>>&);
ExceptionOr<void> removeTrack(RTCRtpSender&);
using AddTransceiverTrackOrKind = Variant<RefPtr<MediaStreamTrack>, String>;
ExceptionOr<Ref<RTCRtpTransceiver>> addTransceiver(AddTransceiverTrackOrKind&&, const RTCRtpTransceiverInit&);
ExceptionOr<Ref<RTCDataChannel>> createDataChannel(String&&, RTCDataChannelInit&&);
void getStats(MediaStreamTrack*, Ref<DeferredPromise>&&);
EventTargetInterface eventTargetInterface() const final { return RTCPeerConnectionEventTargetInterfaceType; }
ScriptExecutionContext* scriptExecutionContext() const final { return ActiveDOMObject::scriptExecutionContext(); }
using RefCounted::ref;
using RefCounted::deref;
WEBCORE_EXPORT void emulatePlatformEvent(const String& action);
void addTransceiver(Ref<RTCRtpTransceiver>&&);
void setSignalingState(RTCSignalingState);
void updateIceGatheringState(RTCIceGatheringState);
void updateIceConnectionState(RTCIceConnectionState);
void scheduleNegotiationNeededEvent();
void dispatchEventWhenFeasible(Ref<Event>&&);
void disableICECandidateFiltering() { m_backend->disableICECandidateFiltering(); }
void enableICECandidateFiltering() { m_backend->enableICECandidateFiltering(); }
void clearController() { m_controller = nullptr; }
Document* document();
void doTask(Function<void()>&&);
#if !RELEASE_LOG_DISABLED
const Logger& logger() const final { return m_logger.get(); }
const void* logIdentifier() const final { return m_logIdentifier; }
const char* logClassName() const final { return "RTCPeerConnection"; }
WTFLogChannel& logChannel() const final;
#endif
private:
template<typename PromiseType> void addPendingPromise(PromiseType& promise)
{
promise.whenSettled([pendingActivity = makePendingActivity(*this)] { });
}
RTCPeerConnection(Document&);
ExceptionOr<void> initializeConfiguration(RTCConfiguration&&);
void registerToController(RTCController&);
void unregisterFromController();
friend class Internals;
void applyRotationForOutgoingVideoSources() { m_backend->applyRotationForOutgoingVideoSources(); }
void refEventTarget() final { ref(); }
void derefEventTarget() final { deref(); }
void dispatchEvent(Event&) final;
WEBCORE_EXPORT void stop() final;
const char* activeDOMObjectName() const final;
void suspend(ReasonForSuspension) final;
void resume() final;
bool virtualHasPendingActivity() const final;
void updateConnectionState();
bool doClose();
void doStop();
ExceptionOr<Vector<MediaEndpointConfiguration::CertificatePEM>> certificatesFromConfiguration(const RTCConfiguration&);
ExceptionOr<Vector<MediaEndpointConfiguration::IceServerInfo>> iceServersFromConfiguration(RTCConfiguration& newConfiguration, const RTCConfiguration* existingConfiguration, bool isLocalDescriptionSet);
bool m_isStopped { false };
RTCSignalingState m_signalingState { RTCSignalingState::Stable };
RTCIceGatheringState m_iceGatheringState { RTCIceGatheringState::New };
RTCIceConnectionState m_iceConnectionState { RTCIceConnectionState::New };
RTCPeerConnectionState m_connectionState { RTCPeerConnectionState::New };
#if !RELEASE_LOG_DISABLED
Ref<const Logger> m_logger;
const void* m_logIdentifier;
#endif
std::unique_ptr<RtpTransceiverSet> m_transceiverSet { std::unique_ptr<RtpTransceiverSet>(new RtpTransceiverSet()) };
std::unique_ptr<PeerConnectionBackend> m_backend;
RTCConfiguration m_configuration;
RTCController* m_controller { nullptr };
Vector<RefPtr<RTCCertificate>> m_certificates;
bool m_shouldDelayTasks { false };
Vector<Function<void()>> m_pendingTasks;
};
}
#endif // ENABLE(WEB_RTC)