RTCPeerConnection.h [plain text]
#pragma once
#if ENABLE(WEB_RTC)
#include "ActiveDOMObject.h"
#include "EventTarget.h"
#include "MediaStream.h"
#include "RTCConfiguration.h"
#include "RTCDataChannel.h"
#include "RTCOfferAnswerOptions.h"
#include "RTCRtpTransceiver.h"
namespace WebCore {
class MediaStreamTrack;
class PeerConnectionBackend;
class RTCIceCandidate;
class RTCPeerConnectionErrorCallback;
class RTCSessionDescription;
class RTCStatsCallback;
class RTCPeerConnection final : public RefCounted<RTCPeerConnection>, public RTCRtpSenderClient, public EventTargetWithInlineData, public ActiveDOMObject {
public:
static Ref<RTCPeerConnection> create(ScriptExecutionContext&);
virtual ~RTCPeerConnection();
using AnswerOptions = RTCAnswerOptions;
using DataChannelInit = RTCDataChannelInit;
using OfferAnswerOptions = RTCOfferAnswerOptions;
using OfferOptions = RTCOfferOptions;
ExceptionOr<void> initializeWith(Document&, RTCConfiguration&&);
const Vector<std::reference_wrapper<RTCRtpSender>>& getSenders() const { return m_transceiverSet->senders(); }
const Vector<std::reference_wrapper<RTCRtpReceiver>>& getReceivers() const { return m_transceiverSet->receivers(); }
const Vector<RefPtr<RTCRtpTransceiver>>& getTransceivers() const { return m_transceiverSet->list(); }
Vector<RefPtr<MediaStream>> getRemoteStreams() const { return m_backend->getRemoteStreams(); }
ExceptionOr<Ref<RTCRtpSender>> addTrack(Ref<MediaStreamTrack>&&, const Vector<std::reference_wrapper<MediaStream>>&);
ExceptionOr<void> removeTrack(RTCRtpSender&);
enum class RtpTransceiverDirection { Sendrecv, Sendonly, Recvonly, Inactive };
struct RtpTransceiverInit {
RtpTransceiverDirection direction;
};
ExceptionOr<Ref<RTCRtpTransceiver>> addTransceiver(Ref<MediaStreamTrack>&&, const RtpTransceiverInit&);
ExceptionOr<Ref<RTCRtpTransceiver>> addTransceiver(const String& kind, const RtpTransceiverInit&);
void queuedCreateOffer(RTCOfferOptions&&, PeerConnection::SessionDescriptionPromise&&);
void queuedCreateAnswer(RTCAnswerOptions&&, PeerConnection::SessionDescriptionPromise&&);
void queuedSetLocalDescription(RTCSessionDescription&, DOMPromise<void>&&);
RefPtr<RTCSessionDescription> localDescription() const;
RefPtr<RTCSessionDescription> currentLocalDescription() const;
RefPtr<RTCSessionDescription> pendingLocalDescription() const;
void queuedSetRemoteDescription(RTCSessionDescription&, DOMPromise<void>&&);
RefPtr<RTCSessionDescription> remoteDescription() const;
RefPtr<RTCSessionDescription> currentRemoteDescription() const;
RefPtr<RTCSessionDescription> pendingRemoteDescription() const;
String signalingState() const;
void queuedAddIceCandidate(RTCIceCandidate&, DOMPromise<void>&&);
String iceGatheringState() const;
String iceConnectionState() const;
const RTCConfiguration& getConfiguration() const { return m_configuration; }
ExceptionOr<void> setConfiguration(RTCConfiguration&&);
void privateGetStats(MediaStreamTrack*, PeerConnection::StatsPromise&&);
ExceptionOr<Ref<RTCDataChannel>> createDataChannel(ScriptExecutionContext&, String&&, RTCDataChannelInit&&);
void close();
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(PeerConnectionStates::SignalingState);
void updateIceGatheringState(PeerConnectionStates::IceGatheringState);
void updateIceConnectionState(PeerConnectionStates::IceConnectionState);
void scheduleNegotiationNeededEvent();
RTCRtpSenderClient& senderClient() { return *this; }
void fireEvent(Event&);
PeerConnectionStates::SignalingState internalSignalingState() const { return m_signalingState; }
PeerConnectionStates::IceGatheringState internalIceGatheringState() const { return m_iceGatheringState; }
PeerConnectionStates::IceConnectionState internalIceConnectionState() const { return m_iceConnectionState; }
private:
RTCPeerConnection(ScriptExecutionContext&);
void completeAddTransceiver(RTCRtpTransceiver&, const RtpTransceiverInit&);
void refEventTarget() final { ref(); }
void derefEventTarget() final { deref(); }
void stop() final;
const char* activeDOMObjectName() const final;
bool canSuspendForDocumentSuspension() const final;
void replaceTrack(RTCRtpSender&, RefPtr<MediaStreamTrack>&&, DOMPromise<void>&&) final;
PeerConnectionStates::SignalingState m_signalingState { PeerConnectionStates::SignalingState::Stable };
PeerConnectionStates::IceGatheringState m_iceGatheringState { PeerConnectionStates::IceGatheringState::New };
PeerConnectionStates::IceConnectionState m_iceConnectionState { PeerConnectionStates::IceConnectionState::New };
std::unique_ptr<RtpTransceiverSet> m_transceiverSet { std::unique_ptr<RtpTransceiverSet>(new RtpTransceiverSet()) };
Vector<RefPtr<RTCDataChannel>> m_dataChannels;
std::unique_ptr<PeerConnectionBackend> m_backend;
RTCConfiguration m_configuration;
};
}
#endif // ENABLE(WEB_RTC)