Replace WTF::move with WTFMove
[WebKit-https.git] / Source / WebCore / Modules / mediastream / RTCPeerConnection.cpp
1 /*
2  * Copyright (C) 2012 Google Inc. All rights reserved.
3  * Copyright (C) 2013 Nokia Corporation and/or its subsidiary(-ies).
4  * Copyright (C) 2015 Ericsson AB. All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  *
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer
14  *    in the documentation and/or other materials provided with the
15  *    distribution.
16  * 3. Neither the name of Google Inc. nor the names of its contributors
17  *    may be used to endorse or promote products derived from this
18  *    software without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31  */
32
33 #include "config.h"
34
35 #if ENABLE(MEDIA_STREAM)
36
37 #include "RTCPeerConnection.h"
38
39 #include "DOMError.h"
40 #include "Document.h"
41 #include "Event.h"
42 #include "ExceptionCode.h"
43 #include "Frame.h"
44 #include "JSDOMError.h"
45 #include "MediaStream.h"
46 #include "MediaStreamTrack.h"
47 #include "RTCConfiguration.h"
48 #include "RTCDataChannel.h"
49 #include "RTCIceCandidate.h"
50 #include "RTCIceCandidateEvent.h"
51 #include "RTCOfferAnswerOptions.h"
52 #include "RTCRtpReceiver.h"
53 #include "RTCRtpSender.h"
54 #include "RTCSessionDescription.h"
55 #include "RTCTrackEvent.h"
56 #include <wtf/MainThread.h>
57 #include <wtf/text/Base64.h>
58
59 namespace WebCore {
60
61 using namespace PeerConnection;
62 using namespace PeerConnectionStates;
63
64 RefPtr<RTCPeerConnection> RTCPeerConnection::create(ScriptExecutionContext& context, const Dictionary& rtcConfiguration, ExceptionCode& ec)
65 {
66     RefPtr<RTCConfiguration> configuration = RTCConfiguration::create(rtcConfiguration, ec);
67     if (ec)
68         return nullptr;
69
70     RefPtr<RTCPeerConnection> peerConnection = adoptRef(new RTCPeerConnection(context, WTFMove(configuration), ec));
71     peerConnection->suspendIfNeeded();
72     if (ec)
73         return nullptr;
74
75     return peerConnection;
76 }
77
78 RTCPeerConnection::RTCPeerConnection(ScriptExecutionContext& context, RefPtr<RTCConfiguration>&& configuration, ExceptionCode& ec)
79     : ActiveDOMObject(&context)
80     , m_signalingState(SignalingState::Stable)
81     , m_iceGatheringState(IceGatheringState::New)
82     , m_iceConnectionState(IceConnectionState::New)
83     , m_configuration(WTFMove(configuration))
84     , m_stopped(false)
85 {
86     Document& document = downcast<Document>(context);
87
88     if (!document.frame()) {
89         ec = NOT_SUPPORTED_ERR;
90         return;
91     }
92
93     m_backend = PeerConnectionBackend::create(this);
94     if (!m_backend) {
95         ec = NOT_SUPPORTED_ERR;
96         return;
97     }
98
99     m_backend->setConfiguration(*m_configuration);
100 }
101
102 RTCPeerConnection::~RTCPeerConnection()
103 {
104     stop();
105 }
106
107 Vector<RefPtr<RTCRtpSender>> RTCPeerConnection::getSenders() const
108 {
109     Vector<RefPtr<RTCRtpSender>> senders;
110     senders.reserveCapacity(m_senderSet.size());
111     copyValuesToVector(m_senderSet, senders);
112
113     return senders;
114 }
115
116 Vector<RefPtr<RTCRtpReceiver>> RTCPeerConnection::getReceivers() const
117 {
118     Vector<RefPtr<RTCRtpReceiver>> receivers;
119     receivers.reserveCapacity(m_receiverSet.size());
120     copyValuesToVector(m_receiverSet, receivers);
121
122     return receivers;
123 }
124
125 RefPtr<RTCRtpSender> RTCPeerConnection::addTrack(RefPtr<MediaStreamTrack>&& track, Vector<MediaStream*> streams, ExceptionCode& ec)
126 {
127     if (!track) {
128         ec = TypeError;
129         return nullptr;
130     }
131
132     if (m_signalingState == SignalingState::Closed) {
133         ec = INVALID_STATE_ERR;
134         return nullptr;
135     }
136
137     // Require at least one stream until https://github.com/w3c/webrtc-pc/issues/288 is resolved
138     if (!streams.size()) {
139         ec = NOT_SUPPORTED_ERR;
140         return nullptr;
141     }
142
143     if (m_senderSet.contains(track->id())) {
144         // FIXME: Spec says InvalidParameter
145         ec = INVALID_MODIFICATION_ERR;
146         return nullptr;
147     }
148
149     const String& trackId = track->id();
150     RefPtr<RTCRtpSender> sender = RTCRtpSender::create(WTFMove(track), streams[0]->id());
151     m_senderSet.add(trackId, sender);
152
153     m_backend->markAsNeedingNegotiation();
154
155     return sender;
156 }
157
158 void RTCPeerConnection::removeTrack(RTCRtpSender* sender, ExceptionCode& ec)
159 {
160     if (!sender) {
161         ec = TypeError;
162         return;
163     }
164
165     if (m_signalingState == SignalingState::Closed) {
166         ec = INVALID_STATE_ERR;
167         return;
168     }
169
170     if (!m_senderSet.remove(sender->track()->id()))
171         return;
172
173     m_backend->markAsNeedingNegotiation();
174 }
175
176 void RTCPeerConnection::queuedCreateOffer(const Dictionary& offerOptions, SessionDescriptionPromise&& promise)
177 {
178     if (m_signalingState == SignalingState::Closed) {
179         promise.reject(DOMError::create("InvalidStateError"));
180         return;
181     }
182
183     ExceptionCode ec = 0;
184     RefPtr<RTCOfferOptions> options = RTCOfferOptions::create(offerOptions, ec);
185     if (ec) {
186         promise.reject(DOMError::create("Invalid createOffer argument"));
187         return;
188     }
189     ASSERT(options);
190
191     m_backend->createOffer(*options, WTFMove(promise));
192 }
193
194 void RTCPeerConnection::queuedCreateAnswer(const Dictionary& answerOptions, SessionDescriptionPromise&& promise)
195 {
196     if (m_signalingState == SignalingState::Closed) {
197         promise.reject(DOMError::create("InvalidStateError"));
198         return;
199     }
200
201     ExceptionCode ec = 0;
202     RefPtr<RTCAnswerOptions> options = RTCAnswerOptions::create(answerOptions, ec);
203     if (ec) {
204         promise.reject(DOMError::create("Invalid createAnswer argument"));
205         return;
206     }
207
208     m_backend->createAnswer(*options, WTFMove(promise));
209 }
210
211 void RTCPeerConnection::queuedSetLocalDescription(RTCSessionDescription* description, PeerConnection::VoidPromise&& promise)
212 {
213     if (m_signalingState == SignalingState::Closed) {
214         promise.reject(DOMError::create("InvalidStateError"));
215         return;
216     }
217
218     ASSERT(description);
219     m_backend->setLocalDescription(*description, WTFMove(promise));
220 }
221
222 RefPtr<RTCSessionDescription> RTCPeerConnection::localDescription() const
223 {
224     return m_backend->localDescription();
225 }
226
227 RefPtr<RTCSessionDescription> RTCPeerConnection::currentLocalDescription() const
228 {
229     return m_backend->currentLocalDescription();
230 }
231
232 RefPtr<RTCSessionDescription> RTCPeerConnection::pendingLocalDescription() const
233 {
234     return m_backend->pendingLocalDescription();
235 }
236
237 void RTCPeerConnection::queuedSetRemoteDescription(RTCSessionDescription* description, PeerConnection::VoidPromise&& promise)
238 {
239     if (m_signalingState == SignalingState::Closed) {
240         promise.reject(DOMError::create("InvalidStateError"));
241         return;
242     }
243
244     ASSERT(description);
245     m_backend->setRemoteDescription(*description, WTFMove(promise));
246 }
247
248 RefPtr<RTCSessionDescription> RTCPeerConnection::remoteDescription() const
249 {
250     return m_backend->remoteDescription();
251 }
252
253 RefPtr<RTCSessionDescription> RTCPeerConnection::currentRemoteDescription() const
254 {
255     return m_backend->currentRemoteDescription();
256 }
257
258 RefPtr<RTCSessionDescription> RTCPeerConnection::pendingRemoteDescription() const
259 {
260     return m_backend->pendingRemoteDescription();
261 }
262
263 void RTCPeerConnection::queuedAddIceCandidate(RTCIceCandidate* rtcCandidate, VoidPromise&& promise)
264 {
265     if (m_signalingState == SignalingState::Closed) {
266         promise.reject(DOMError::create("InvalidStateError"));
267         return;
268     }
269
270     ASSERT(rtcCandidate);
271     m_backend->addIceCandidate(*rtcCandidate, WTFMove(promise));
272 }
273
274 String RTCPeerConnection::signalingState() const
275 {
276     switch (m_signalingState) {
277     case SignalingState::Stable:
278         return ASCIILiteral("stable");
279     case SignalingState::HaveLocalOffer:
280         return ASCIILiteral("have-local-offer");
281     case SignalingState::HaveRemoteOffer:
282         return ASCIILiteral("have-remote-offer");
283     case SignalingState::HaveLocalPrAnswer:
284         return ASCIILiteral("have-local-pranswer");
285     case SignalingState::HaveRemotePrAnswer:
286         return ASCIILiteral("have-remote-pranswer");
287     case SignalingState::Closed:
288         return ASCIILiteral("closed");
289     }
290
291     ASSERT_NOT_REACHED();
292     return String();
293 }
294
295 String RTCPeerConnection::iceGatheringState() const
296 {
297     switch (m_iceGatheringState) {
298     case IceGatheringState::New:
299         return ASCIILiteral("new");
300     case IceGatheringState::Gathering:
301         return ASCIILiteral("gathering");
302     case IceGatheringState::Complete:
303         return ASCIILiteral("complete");
304     }
305
306     ASSERT_NOT_REACHED();
307     return String();
308 }
309
310 String RTCPeerConnection::iceConnectionState() const
311 {
312     switch (m_iceConnectionState) {
313     case IceConnectionState::New:
314         return ASCIILiteral("new");
315     case IceConnectionState::Checking:
316         return ASCIILiteral("checking");
317     case IceConnectionState::Connected:
318         return ASCIILiteral("connected");
319     case IceConnectionState::Completed:
320         return ASCIILiteral("completed");
321     case IceConnectionState::Failed:
322         return ASCIILiteral("failed");
323     case IceConnectionState::Disconnected:
324         return ASCIILiteral("disconnected");
325     case IceConnectionState::Closed:
326         return ASCIILiteral("closed");
327     }
328
329     ASSERT_NOT_REACHED();
330     return String();
331 }
332
333 RTCConfiguration* RTCPeerConnection::getConfiguration() const
334 {
335     return m_configuration.get();
336 }
337
338 void RTCPeerConnection::setConfiguration(const Dictionary& configuration, ExceptionCode& ec)
339 {
340     if (configuration.isUndefinedOrNull()) {
341         ec = TypeError;
342         return;
343     }
344
345     if (m_signalingState == SignalingState::Closed) {
346         ec = INVALID_STATE_ERR;
347         return;
348     }
349
350     RefPtr<RTCConfiguration> newConfiguration = RTCConfiguration::create(configuration, ec);
351     if (ec)
352         return;
353
354     m_configuration = WTFMove(newConfiguration);
355     m_backend->setConfiguration(*m_configuration);
356 }
357
358 void RTCPeerConnection::privateGetStats(MediaStreamTrack* selector, PeerConnection::StatsPromise&& promise)
359 {
360     m_backend->getStats(selector, WTFMove(promise));
361 }
362
363 void RTCPeerConnection::privateGetStats(PeerConnection::StatsPromise&& promise)
364 {
365     privateGetStats(nullptr, WTFMove(promise));
366 }
367
368 RefPtr<RTCDataChannel> RTCPeerConnection::createDataChannel(String, const Dictionary&, ExceptionCode& ec)
369 {
370     if (m_signalingState == SignalingState::Closed) {
371         ec = INVALID_STATE_ERR;
372         return nullptr;
373     }
374
375     return nullptr;
376 }
377
378 void RTCPeerConnection::close()
379 {
380     if (m_signalingState == SignalingState::Closed)
381         return;
382
383     m_signalingState = SignalingState::Closed;
384 }
385
386 void RTCPeerConnection::stop()
387 {
388     if (m_stopped)
389         return;
390
391     m_stopped = true;
392     m_iceConnectionState = IceConnectionState::Closed;
393     m_signalingState = SignalingState::Closed;
394 }
395
396 const char* RTCPeerConnection::activeDOMObjectName() const
397 {
398     return "RTCPeerConnection";
399 }
400
401 bool RTCPeerConnection::canSuspendForDocumentSuspension() const
402 {
403     // FIXME: We should try and do better here.
404     return false;
405 }
406
407 void RTCPeerConnection::setSignalingState(SignalingState newState)
408 {
409     m_signalingState = newState;
410 }
411
412 void RTCPeerConnection::updateIceGatheringState(IceGatheringState newState)
413 {
414     scriptExecutionContext()->postTask([=](ScriptExecutionContext&) {
415         m_iceGatheringState = newState;
416
417         dispatchEvent(Event::create(eventNames().icegatheringstatechangeEvent, false, false));
418     });
419 }
420
421 void RTCPeerConnection::updateIceConnectionState(IceConnectionState newState)
422 {
423     scriptExecutionContext()->postTask([=](ScriptExecutionContext&) {
424         m_iceConnectionState = newState;
425
426         dispatchEvent(Event::create(eventNames().iceconnectionstatechangeEvent, false, false));
427     });
428 }
429
430 void RTCPeerConnection::scheduleNegotiationNeededEvent()
431 {
432     scriptExecutionContext()->postTask([=](ScriptExecutionContext&) {
433         if (m_backend->isNegotiationNeeded()) {
434             dispatchEvent(Event::create(eventNames().negotiationneededEvent, false, false));
435             m_backend->clearNegotiationNeededState();
436         }
437     });
438 }
439
440 void RTCPeerConnection::fireEvent(Event& event)
441 {
442     dispatchEvent(event);
443 }
444
445 } // namespace WebCore
446
447 #endif // ENABLE(MEDIA_STREAM)