LibWebRTCProvider.h [plain text]
#pragma once
#include "DocumentIdentifier.h"
#include "LibWebRTCMacros.h"
#include <wtf/CompletionHandler.h>
#include <wtf/Expected.h>
#include <wtf/UniqueRef.h>
#include <wtf/text/WTFString.h>
#if USE(LIBWEBRTC)
ALLOW_UNUSED_PARAMETERS_BEGIN
#include <webrtc/api/peer_connection_interface.h>
#include <webrtc/api/video_codecs/video_encoder_factory.h>
#include <webrtc/api/video_codecs/video_decoder_factory.h>
#include <webrtc/api/scoped_refptr.h>
ALLOW_UNUSED_PARAMETERS_END
namespace rtc {
class NetworkManager;
class PacketSocketFactory;
class Thread;
class RTCCertificateGenerator;
}
namespace webrtc {
class AsyncResolverFactory;
class PeerConnectionFactoryInterface;
}
#endif
namespace WebCore {
class LibWebRTCAudioModule;
struct PeerConnectionFactoryAndThreads;
struct RTCRtpCapabilities;
enum class MDNSRegisterError { NotImplemented, BadParameter, DNSSD, Internal, Timeout };
class WEBCORE_EXPORT LibWebRTCProvider {
WTF_MAKE_FAST_ALLOCATED;
public:
static UniqueRef<LibWebRTCProvider> create();
virtual ~LibWebRTCProvider() = default;
static bool webRTCAvailable();
static void registerWebKitVP9Decoder();
virtual void setActive(bool);
virtual void setH264HardwareEncoderAllowed(bool) { }
using IPAddressOrError = Expected<String, MDNSRegisterError>;
using MDNSNameOrError = Expected<String, MDNSRegisterError>;
virtual void unregisterMDNSNames(DocumentIdentifier) { }
virtual void registerMDNSName(DocumentIdentifier, const String& ipAddress, CompletionHandler<void(MDNSNameOrError&&)>&& callback)
{
UNUSED_PARAM(ipAddress);
callback(makeUnexpected(MDNSRegisterError::NotImplemented));
}
#if USE(LIBWEBRTC)
virtual rtc::scoped_refptr<webrtc::PeerConnectionInterface> createPeerConnection(webrtc::PeerConnectionObserver&, rtc::PacketSocketFactory*, webrtc::PeerConnectionInterface::RTCConfiguration&&);
webrtc::PeerConnectionFactoryInterface* factory();
static void callOnWebRTCNetworkThread(Function<void()>&&);
static void callOnWebRTCSignalingThread(Function<void()>&&);
static bool hasWebRTCThreads();
void setPeerConnectionFactory(rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface>&&);
void disableEnumeratingAllNetworkInterfaces();
void enableEnumeratingAllNetworkInterfaces();
void setH265Support(bool value) { m_supportsH265 = value; }
void setVP9Support(bool value) { m_supportsVP9 = value; }
bool isSupportingH265() const { return m_supportsH265; }
bool isSupportingVP9() const { return m_supportsVP9; }
virtual void disableNonLocalhostConnections() { m_disableNonLocalhostConnections = true; }
void prepareCertificateGenerator(Function<void(rtc::RTCCertificateGenerator&)>&&);
Optional<RTCRtpCapabilities> receiverCapabilities(const String& kind);
Optional<RTCRtpCapabilities> senderCapabilities(const String& kind);
void clearFactory() { m_factory = nullptr; }
void setEnableLogging(bool);
void setEnableWebRTCEncryption(bool);
void setUseDTLS10(bool);
class SuspendableSocketFactory : public rtc::PacketSocketFactory {
public:
virtual ~SuspendableSocketFactory() = default;
virtual void suspend() { };
virtual void resume() { };
};
virtual std::unique_ptr<SuspendableSocketFactory> createSocketFactory(String&& ) { return nullptr; }
protected:
LibWebRTCProvider() = default;
rtc::scoped_refptr<webrtc::PeerConnectionInterface> createPeerConnection(webrtc::PeerConnectionObserver&, rtc::NetworkManager&, rtc::PacketSocketFactory&, webrtc::PeerConnectionInterface::RTCConfiguration&&, std::unique_ptr<webrtc::AsyncResolverFactory>&&);
rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> createPeerConnectionFactory(rtc::Thread* networkThread, rtc::Thread* signalingThread);
virtual std::unique_ptr<webrtc::VideoDecoderFactory> createDecoderFactory();
virtual std::unique_ptr<webrtc::VideoEncoderFactory> createEncoderFactory();
virtual void startedNetworkThread() { };
PeerConnectionFactoryAndThreads& getStaticFactoryAndThreads(bool useNetworkThreadWithSocketServer);
bool m_enableEnumeratingAllNetworkInterfaces { false };
bool m_useNetworkThreadWithSocketServer { true };
rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> m_factory;
bool m_disableNonLocalhostConnections { false };
bool m_supportsH265 { false };
bool m_supportsVP9 { false };
bool m_enableLogging { true };
bool m_useDTLS10 { false };
#endif
};
}
namespace WTF {
template<> struct EnumTraits<WebCore::MDNSRegisterError> {
using values = EnumValues<
WebCore::MDNSRegisterError,
WebCore::MDNSRegisterError::NotImplemented,
WebCore::MDNSRegisterError::BadParameter,
WebCore::MDNSRegisterError::DNSSD,
WebCore::MDNSRegisterError::Internal,
WebCore::MDNSRegisterError::Timeout
>;
};
}