29f13896c0868004a822c54d602adac865e82881
[WebKit-https.git] / Source / WebCore / Modules / mediastream / RTCPeerConnection.h
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 #pragma once
34
35 #if ENABLE(WEB_RTC)
36
37 #include "ActiveDOMObject.h"
38 #include "EventTarget.h"
39 #include "MediaStream.h"
40 #include "RTCConfiguration.h"
41 #include "RTCDataChannel.h"
42 #include "RTCOfferAnswerOptions.h"
43 #include "RTCRtpTransceiver.h"
44
45 namespace WebCore {
46
47 class MediaStreamTrack;
48 class PeerConnectionBackend;
49 class RTCController;
50 class RTCIceCandidate;
51 class RTCPeerConnectionErrorCallback;
52 class RTCSessionDescription;
53 class RTCStatsCallback;
54
55 class RTCPeerConnection final : public RefCounted<RTCPeerConnection>, public RTCRtpSenderClient, public EventTargetWithInlineData, public ActiveDOMObject {
56 public:
57     static Ref<RTCPeerConnection> create(ScriptExecutionContext&);
58     virtual ~RTCPeerConnection();
59
60     using AnswerOptions = RTCAnswerOptions;
61     using DataChannelInit = RTCDataChannelInit;
62     using OfferAnswerOptions = RTCOfferAnswerOptions;
63     using OfferOptions = RTCOfferOptions;
64
65     ExceptionOr<void> initializeWith(Document&, RTCConfiguration&&);
66
67     const Vector<std::reference_wrapper<RTCRtpSender>>& getSenders() const { return m_transceiverSet->senders(); }
68     const Vector<std::reference_wrapper<RTCRtpReceiver>>& getReceivers() const { return m_transceiverSet->receivers(); }
69     const Vector<RefPtr<RTCRtpTransceiver>>& getTransceivers() const { return m_transceiverSet->list(); }
70
71     // Part of legacy MediaStream-based API (mostly implemented as JS built-ins)
72     Vector<RefPtr<MediaStream>> getRemoteStreams() const { return m_backend->getRemoteStreams(); }
73
74     ExceptionOr<Ref<RTCRtpSender>> addTrack(Ref<MediaStreamTrack>&&, const Vector<std::reference_wrapper<MediaStream>>&);
75     ExceptionOr<void> removeTrack(RTCRtpSender&);
76
77     // This enum is mirrored in RTCRtpTransceiver.h
78     enum class RtpTransceiverDirection { Sendrecv, Sendonly, Recvonly, Inactive };
79
80     struct RtpTransceiverInit {
81         RtpTransceiverDirection direction;
82     };
83
84     ExceptionOr<Ref<RTCRtpTransceiver>> addTransceiver(Ref<MediaStreamTrack>&&, const RtpTransceiverInit&);
85     ExceptionOr<Ref<RTCRtpTransceiver>> addTransceiver(const String& kind, const RtpTransceiverInit&);
86
87     void queuedCreateOffer(RTCOfferOptions&&, PeerConnection::SessionDescriptionPromise&&);
88     void queuedCreateAnswer(RTCAnswerOptions&&, PeerConnection::SessionDescriptionPromise&&);
89
90     void queuedSetLocalDescription(RTCSessionDescription&, DOMPromise<void>&&);
91     RefPtr<RTCSessionDescription> localDescription() const;
92     RefPtr<RTCSessionDescription> currentLocalDescription() const;
93     RefPtr<RTCSessionDescription> pendingLocalDescription() const;
94
95     void queuedSetRemoteDescription(RTCSessionDescription&, DOMPromise<void>&&);
96     RefPtr<RTCSessionDescription> remoteDescription() const;
97     RefPtr<RTCSessionDescription> currentRemoteDescription() const;
98     RefPtr<RTCSessionDescription> pendingRemoteDescription() const;
99
100     String signalingState() const;
101
102     void queuedAddIceCandidate(RTCIceCandidate&, DOMPromise<void>&&);
103
104     String iceGatheringState() const;
105     String iceConnectionState() const;
106
107     const RTCConfiguration& getConfiguration() const { return m_configuration; }
108     ExceptionOr<void> setConfiguration(RTCConfiguration&&);
109
110     void getStats(MediaStreamTrack*, Ref<DeferredPromise>&&);
111
112     ExceptionOr<Ref<RTCDataChannel>> createDataChannel(ScriptExecutionContext&, String&&, RTCDataChannelInit&&);
113
114     void close();
115
116     // EventTarget
117     EventTargetInterface eventTargetInterface() const final { return RTCPeerConnectionEventTargetInterfaceType; }
118     ScriptExecutionContext* scriptExecutionContext() const final { return ActiveDOMObject::scriptExecutionContext(); }
119
120     using RefCounted::ref;
121     using RefCounted::deref;
122
123     // Used for testing with a mock
124     WEBCORE_EXPORT void emulatePlatformEvent(const String& action);
125
126     // API used by PeerConnectionBackend and relatives
127     void addTransceiver(Ref<RTCRtpTransceiver>&&);
128     void setSignalingState(PeerConnectionStates::SignalingState);
129     void updateIceGatheringState(PeerConnectionStates::IceGatheringState);
130     void updateIceConnectionState(PeerConnectionStates::IceConnectionState);
131
132     void scheduleNegotiationNeededEvent();
133
134     RTCRtpSenderClient& senderClient() { return *this; }
135     void fireEvent(Event&);
136     PeerConnectionStates::SignalingState internalSignalingState() const { return m_signalingState; }
137     PeerConnectionStates::IceGatheringState internalIceGatheringState() const { return m_iceGatheringState; }
138     PeerConnectionStates::IceConnectionState internalIceConnectionState() const { return m_iceConnectionState; }
139
140     void disableICECandidateFiltering() { m_backend->disableICECandidateFiltering(); }
141     void enableICECandidateFiltering() { m_backend->enableICECandidateFiltering(); }
142
143 private:
144     RTCPeerConnection(ScriptExecutionContext&);
145
146     void completeAddTransceiver(RTCRtpTransceiver&, const RtpTransceiverInit&);
147
148     RTCController& rtcController();
149     void registerToController();
150     void unregisterFromController();
151
152     // EventTarget implementation.
153     void refEventTarget() final { ref(); }
154     void derefEventTarget() final { deref(); }
155
156     // ActiveDOMObject
157     void stop() final;
158     const char* activeDOMObjectName() const final;
159     bool canSuspendForDocumentSuspension() const final;
160
161     // RTCRtpSenderClient
162     void replaceTrack(RTCRtpSender&, Ref<MediaStreamTrack>&&, DOMPromise<void>&&) final;
163
164     PeerConnectionStates::SignalingState m_signalingState { PeerConnectionStates::SignalingState::Stable };
165     PeerConnectionStates::IceGatheringState m_iceGatheringState { PeerConnectionStates::IceGatheringState::New };
166     PeerConnectionStates::IceConnectionState m_iceConnectionState { PeerConnectionStates::IceConnectionState::New };
167
168     std::unique_ptr<RtpTransceiverSet> m_transceiverSet { std::unique_ptr<RtpTransceiverSet>(new RtpTransceiverSet()) };
169
170     Vector<RefPtr<RTCDataChannel>> m_dataChannels;
171
172     std::unique_ptr<PeerConnectionBackend> m_backend;
173
174     RTCConfiguration m_configuration;
175 };
176
177 } // namespace WebCore
178
179 #endif // ENABLE(WEB_RTC)