Clean up some includes to make the build a bit faster: DOMPromise
[WebKit-https.git] / Source / WebCore / Modules / mediastream / PeerConnectionBackend.h
1 /*
2  * Copyright (C) 2015 Ericsson AB. All rights reserved.
3  * Copyright (C) 2017 Apple Inc. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer
13  *    in the documentation and/or other materials provided with the
14  *    distribution.
15  * 3. Neither the name of Ericsson nor the names of its contributors
16  *    may be used to endorse or promote products derived from this
17  *    software without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30  */
31
32 #pragma once
33
34 #if ENABLE(WEB_RTC)
35
36 #include "IDLTypes.h"
37 #include "LibWebRTCProvider.h"
38 #include "RTCRtpSendParameters.h"
39 #include "RTCSessionDescription.h"
40 #include "RTCSignalingState.h"
41 #include <wtf/LoggerHelper.h>
42 #include <wtf/WeakPtr.h>
43
44 namespace WebCore {
45
46 class DeferredPromise;
47 class Document;
48 class MediaStream;
49 class MediaStreamTrack;
50 class PeerConnectionBackend;
51 class RTCCertificate;
52 class RTCDataChannelHandler;
53 class RTCIceCandidate;
54 class RTCPeerConnection;
55 class RTCRtpReceiver;
56 class RTCRtpSender;
57 class RTCRtpTransceiver;
58 class RTCSessionDescription;
59 class RTCStatsReport;
60 class ScriptExecutionContext;
61
62 struct MediaEndpointConfiguration;
63 struct RTCAnswerOptions;
64 struct RTCDataChannelInit;
65 struct RTCOfferOptions;
66 struct RTCRtpTransceiverInit;
67
68 template<typename IDLType> class DOMPromiseDeferred;
69
70 namespace PeerConnection {
71 using SessionDescriptionPromise = DOMPromiseDeferred<IDLDictionary<RTCSessionDescription::Init>>;
72 using StatsPromise = DOMPromiseDeferred<IDLInterface<RTCStatsReport>>;
73 }
74
75 using CreatePeerConnectionBackend = std::unique_ptr<PeerConnectionBackend> (*)(RTCPeerConnection&);
76
77 class PeerConnectionBackend
78     : public CanMakeWeakPtr<PeerConnectionBackend>
79 #if !RELEASE_LOG_DISABLED
80     , private LoggerHelper
81 #endif
82 {
83 public:
84     WEBCORE_EXPORT static CreatePeerConnectionBackend create;
85
86     static Optional<RTCRtpCapabilities> receiverCapabilities(ScriptExecutionContext&, const String& kind);
87     static Optional<RTCRtpCapabilities> senderCapabilities(ScriptExecutionContext&, const String& kind);
88
89     explicit PeerConnectionBackend(RTCPeerConnection&);
90     virtual ~PeerConnectionBackend();
91
92     void createOffer(RTCOfferOptions&&, PeerConnection::SessionDescriptionPromise&&);
93     void createAnswer(RTCAnswerOptions&&, PeerConnection::SessionDescriptionPromise&&);
94     void setLocalDescription(RTCSessionDescription&, DOMPromiseDeferred<void>&&);
95     void setRemoteDescription(RTCSessionDescription&, DOMPromiseDeferred<void>&&);
96     void addIceCandidate(RTCIceCandidate*, DOMPromiseDeferred<void>&&);
97
98     virtual std::unique_ptr<RTCDataChannelHandler> createDataChannelHandler(const String&, const RTCDataChannelInit&) = 0;
99
100     void stop();
101
102     virtual RefPtr<RTCSessionDescription> localDescription() const = 0;
103     virtual RefPtr<RTCSessionDescription> currentLocalDescription() const = 0;
104     virtual RefPtr<RTCSessionDescription> pendingLocalDescription() const = 0;
105
106     virtual RefPtr<RTCSessionDescription> remoteDescription() const = 0;
107     virtual RefPtr<RTCSessionDescription> currentRemoteDescription() const = 0;
108     virtual RefPtr<RTCSessionDescription> pendingRemoteDescription() const = 0;
109
110     virtual bool setConfiguration(MediaEndpointConfiguration&&) = 0;
111
112     virtual void getStats(Ref<DeferredPromise>&&) = 0;
113     virtual void getStats(RTCRtpSender&, Ref<DeferredPromise>&&) = 0;
114     virtual void getStats(RTCRtpReceiver&, Ref<DeferredPromise>&&) = 0;
115
116     virtual ExceptionOr<Ref<RTCRtpSender>> addTrack(MediaStreamTrack&, Vector<String>&&);
117     virtual void removeTrack(RTCRtpSender&) { }
118
119     virtual ExceptionOr<Ref<RTCRtpTransceiver>> addTransceiver(const String&, const RTCRtpTransceiverInit&);
120     virtual ExceptionOr<Ref<RTCRtpTransceiver>> addTransceiver(Ref<MediaStreamTrack>&&, const RTCRtpTransceiverInit&);
121
122     void markAsNeedingNegotiation();
123     bool isNegotiationNeeded() const { return m_negotiationNeeded; };
124     void clearNegotiationNeededState() { m_negotiationNeeded = false; };
125
126     virtual void emulatePlatformEvent(const String& action) = 0;
127
128     void newICECandidate(String&& sdp, String&& mid, unsigned short sdpMLineIndex, String&& serverURL);
129     void disableICECandidateFiltering();
130     void enableICECandidateFiltering();
131
132     virtual void applyRotationForOutgoingVideoSources() { }
133
134 #if !RELEASE_LOG_DISABLED
135     const Logger& logger() const final { return m_logger.get(); }
136     const void* logIdentifier() const final { return m_logIdentifier; }
137     const char* logClassName() const override { return "PeerConnectionBackend"; }
138     WTFLogChannel& logChannel() const final;
139 #endif
140
141     virtual bool isLocalDescriptionSet() const = 0;
142
143     void finishedRegisteringMDNSName(const String& ipAddress, const String& name);
144
145     struct CertificateInformation {
146         enum class Type { RSASSAPKCS1v15, ECDSAP256 };
147         struct RSA {
148             unsigned modulusLength;
149             int publicExponent;
150         };
151
152         static CertificateInformation RSASSA_PKCS1_v1_5()
153         {
154             return CertificateInformation { Type::RSASSAPKCS1v15 };
155         }
156
157         static CertificateInformation ECDSA_P256()
158         {
159             return CertificateInformation { Type::ECDSAP256 };
160         }
161
162         explicit CertificateInformation(Type type)
163             : type(type)
164         {
165         }
166
167         Type type;
168         Optional<double> expires;
169
170         Optional<RSA> rsaParameters;
171     };
172     static void generateCertificate(Document&, const CertificateInformation&, DOMPromiseDeferred<IDLInterface<RTCCertificate>>&&);
173
174     virtual void collectTransceivers() { };
175
176     ScriptExecutionContext* context() const;
177     RTCRtpTransceiver* transceiverFromSender(const RTCRtpSender&);
178
179     virtual void suspend() { }
180     virtual void resume() { }
181
182 protected:
183     void fireICECandidateEvent(RefPtr<RTCIceCandidate>&&, String&& url);
184     void doneGatheringCandidates();
185
186     void updateSignalingState(RTCSignalingState);
187
188     void createOfferSucceeded(String&&);
189     void createOfferFailed(Exception&&);
190
191     void createAnswerSucceeded(String&&);
192     void createAnswerFailed(Exception&&);
193
194     void setLocalDescriptionSucceeded();
195     void setLocalDescriptionFailed(Exception&&);
196
197     void setRemoteDescriptionSucceeded();
198     void setRemoteDescriptionFailed(Exception&&);
199
200     void addIceCandidateSucceeded();
201     void addIceCandidateFailed(Exception&&);
202
203     String filterSDP(String&&) const;
204
205     struct PendingTrackEvent {
206         Ref<RTCRtpReceiver> receiver;
207         Ref<MediaStreamTrack> track;
208         Vector<RefPtr<MediaStream>> streams;
209         RefPtr<RTCRtpTransceiver> transceiver;
210     };
211     void addPendingTrackEvent(PendingTrackEvent&&);
212
213 private:
214     virtual void doCreateOffer(RTCOfferOptions&&) = 0;
215     virtual void doCreateAnswer(RTCAnswerOptions&&) = 0;
216     virtual void doSetLocalDescription(RTCSessionDescription&) = 0;
217     virtual void doSetRemoteDescription(RTCSessionDescription&) = 0;
218     virtual void doAddIceCandidate(RTCIceCandidate&) = 0;
219     virtual void endOfIceCandidates(DOMPromiseDeferred<void>&&);
220     virtual void doStop() = 0;
221
222     void registerMDNSName(const String& ipAddress);
223
224 protected:
225     RTCPeerConnection& m_peerConnection;
226
227 private:
228     std::unique_ptr<PeerConnection::SessionDescriptionPromise> m_offerAnswerPromise;
229     std::unique_ptr<DOMPromiseDeferred<void>> m_setDescriptionPromise;
230     std::unique_ptr<DOMPromiseDeferred<void>> m_addIceCandidatePromise;
231
232     bool m_shouldFilterICECandidates { true };
233     struct PendingICECandidate {
234         // Fields described in https://www.w3.org/TR/webrtc/#idl-def-rtcicecandidateinit.
235         String sdp;
236         String mid;
237         unsigned short sdpMLineIndex;
238         String serverURL;
239     };
240     Vector<PendingICECandidate> m_pendingICECandidates;
241
242     Vector<PendingTrackEvent> m_pendingTrackEvents;
243
244 #if !RELEASE_LOG_DISABLED
245     Ref<const Logger> m_logger;
246     const void* m_logIdentifier;
247 #endif
248     bool m_negotiationNeeded { false };
249     bool m_finishedGatheringCandidates { false };
250     uint64_t m_waitingForMDNSRegistration { 0 };
251 };
252
253 } // namespace WebCore
254
255 #endif // ENABLE(WEB_RTC)