Convert libwebrtc error types to DOM exceptions
[WebKit-https.git] / Source / WebCore / Modules / mediastream / libwebrtc / LibWebRTCMediaEndpoint.h
1 /*
2  * Copyright (C) 2017-2018 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1.  Redistributions of source code must retain the above copyright
8  *     notice, this list of conditions and the following disclaimer.
9  * 2.  Redistributions in binary form must reproduce the above copyright
10  *     notice, this list of conditions and the following disclaimer in the
11  *     documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
15  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
16  * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY
17  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
18  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
19  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
20  * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
21  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
22  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
23  */
24
25 #pragma once
26
27 #if USE(LIBWEBRTC)
28
29 #include "LibWebRTCObservers.h"
30 #include "LibWebRTCProvider.h"
31 #include "LibWebRTCRtpSenderBackend.h"
32 #include "RTCRtpReceiver.h"
33 #include <Timer.h>
34
35 ALLOW_UNUSED_PARAMETERS_BEGIN
36
37 #include <webrtc/api/jsep.h>
38 #include <webrtc/api/peerconnectioninterface.h>
39 #include <webrtc/pc/peerconnectionfactory.h>
40 #include <webrtc/pc/rtcstatscollector.h>
41
42 ALLOW_UNUSED_PARAMETERS_END
43
44 #include <wtf/LoggerHelper.h>
45 #include <wtf/ThreadSafeRefCounted.h>
46
47 namespace webrtc {
48 class CreateSessionDescriptionObserver;
49 class DataChannelInterface;
50 class IceCandidateInterface;
51 class MediaStreamInterface;
52 class PeerConnectionObserver;
53 class SessionDescriptionInterface;
54 class SetSessionDescriptionObserver;
55 }
56
57 namespace WebCore {
58 class LibWebRTCProvider;
59 class LibWebRTCPeerConnectionBackend;
60 class LibWebRTCRtpReceiverBackend;
61 class LibWebRTCRtpTransceiverBackend;
62 class LibWebRTCStatsCollector;
63 class MediaStreamTrack;
64 class RTCSessionDescription;
65
66 class LibWebRTCMediaEndpoint
67     : public ThreadSafeRefCounted<LibWebRTCMediaEndpoint, WTF::DestructionThread::Main>
68     , private webrtc::PeerConnectionObserver
69     , private webrtc::RTCStatsCollectorCallback
70 #if !RELEASE_LOG_DISABLED
71     , private LoggerHelper
72 #endif
73 {
74 public:
75     static Ref<LibWebRTCMediaEndpoint> create(LibWebRTCPeerConnectionBackend& peerConnection, LibWebRTCProvider& client) { return adoptRef(*new LibWebRTCMediaEndpoint(peerConnection, client)); }
76     virtual ~LibWebRTCMediaEndpoint() = default;
77
78     bool setConfiguration(LibWebRTCProvider&, webrtc::PeerConnectionInterface::RTCConfiguration&&);
79
80     webrtc::PeerConnectionInterface& backend() const { ASSERT(m_backend); return *m_backend.get(); }
81     void doSetLocalDescription(RTCSessionDescription&);
82     void doSetRemoteDescription(RTCSessionDescription&);
83     void doCreateOffer(const RTCOfferOptions&);
84     void doCreateAnswer();
85     void getStats(Ref<DeferredPromise>&&);
86     void getStats(webrtc::RtpReceiverInterface&, Ref<DeferredPromise>&&);
87     void getStats(webrtc::RtpSenderInterface&, Ref<DeferredPromise>&&);
88     std::unique_ptr<RTCDataChannelHandler> createDataChannel(const String&, const RTCDataChannelInit&);
89     bool addIceCandidate(webrtc::IceCandidateInterface& candidate) { return m_backend->AddIceCandidate(&candidate); }
90
91     void stop();
92     bool isStopped() const { return !m_backend; }
93
94     RefPtr<RTCSessionDescription> localDescription() const;
95     RefPtr<RTCSessionDescription> remoteDescription() const;
96     RefPtr<RTCSessionDescription> currentLocalDescription() const;
97     RefPtr<RTCSessionDescription> currentRemoteDescription() const;
98     RefPtr<RTCSessionDescription> pendingLocalDescription() const;
99     RefPtr<RTCSessionDescription> pendingRemoteDescription() const;
100
101     bool addTrack(LibWebRTCRtpSenderBackend&, MediaStreamTrack&, const Vector<String>&);
102     void removeTrack(LibWebRTCRtpSenderBackend&);
103
104     struct Backends {
105         std::unique_ptr<LibWebRTCRtpSenderBackend> senderBackend;
106         std::unique_ptr<LibWebRTCRtpReceiverBackend> receiverBackend;
107         std::unique_ptr<LibWebRTCRtpTransceiverBackend> transceiverBackend;
108     };
109     std::optional<Backends> addTransceiver(const String& trackKind, const RTCRtpTransceiverInit&);
110     std::optional<Backends> addTransceiver(MediaStreamTrack&, const RTCRtpTransceiverInit&);
111     std::unique_ptr<LibWebRTCRtpTransceiverBackend> transceiverBackendFromSender(LibWebRTCRtpSenderBackend&);
112
113     void setSenderSourceFromTrack(LibWebRTCRtpSenderBackend&, MediaStreamTrack&);
114     void collectTransceivers();
115
116 private:
117     LibWebRTCMediaEndpoint(LibWebRTCPeerConnectionBackend&, LibWebRTCProvider&);
118
119     // webrtc::PeerConnectionObserver API
120     void OnSignalingChange(webrtc::PeerConnectionInterface::SignalingState) final;
121     void OnAddStream(rtc::scoped_refptr<webrtc::MediaStreamInterface>) final;
122     void OnRemoveStream(rtc::scoped_refptr<webrtc::MediaStreamInterface>) final;
123     void OnDataChannel(rtc::scoped_refptr<webrtc::DataChannelInterface>) final;
124     void OnAddTrack(rtc::scoped_refptr<webrtc::RtpReceiverInterface>, const std::vector<rtc::scoped_refptr<webrtc::MediaStreamInterface>>&) final;
125     void OnTrack(rtc::scoped_refptr<webrtc::RtpTransceiverInterface>) final;
126     void OnRemoveTrack(rtc::scoped_refptr<webrtc::RtpReceiverInterface>) final;
127
128     void OnRenegotiationNeeded() final;
129     void OnIceConnectionChange(webrtc::PeerConnectionInterface::IceConnectionState) final;
130     void OnIceGatheringChange(webrtc::PeerConnectionInterface::IceGatheringState) final;
131     void OnIceCandidate(const webrtc::IceCandidateInterface*) final;
132     void OnIceCandidatesRemoved(const std::vector<cricket::Candidate>&) final;
133
134     void createSessionDescriptionSucceeded(std::unique_ptr<webrtc::SessionDescriptionInterface>&&);
135     void createSessionDescriptionFailed(ExceptionCode, const char*);
136     void setLocalSessionDescriptionSucceeded();
137     void setLocalSessionDescriptionFailed(ExceptionCode, const char*);
138     void setRemoteSessionDescriptionSucceeded();
139     void setRemoteSessionDescriptionFailed(ExceptionCode, const char*);
140     void addRemoteStream(webrtc::MediaStreamInterface&);
141     void addRemoteTrack(rtc::scoped_refptr<webrtc::RtpReceiverInterface>&&, const std::vector<rtc::scoped_refptr<webrtc::MediaStreamInterface>>&);
142     void removeRemoteStream(webrtc::MediaStreamInterface&);
143     void newTransceiver(rtc::scoped_refptr<webrtc::RtpTransceiverInterface>&&);
144     void removeRemoteTrack(rtc::scoped_refptr<webrtc::RtpReceiverInterface>&&);
145
146     void fireTrackEvent(Ref<RTCRtpReceiver>&&, Ref<MediaStreamTrack>&&, const std::vector<rtc::scoped_refptr<webrtc::MediaStreamInterface>>&, RefPtr<RTCRtpTransceiver>&&);
147
148     template<typename T>
149     std::optional<Backends> createTransceiverBackends(T&&, const RTCRtpTransceiverInit&, LibWebRTCRtpSenderBackend::Source&&);
150
151     void OnStatsDelivered(const rtc::scoped_refptr<const webrtc::RTCStatsReport>&) final;
152     void gatherStatsForLogging();
153     void startLoggingStats();
154     void stopLoggingStats();
155
156     void getStats(Ref<DeferredPromise>&&, WTF::Function<void(rtc::scoped_refptr<LibWebRTCStatsCollector>&&)>&&);
157
158     MediaStream& mediaStreamFromRTCStream(webrtc::MediaStreamInterface&);
159
160     void AddRef() const { ref(); }
161     rtc::RefCountReleaseStatus Release() const
162     {
163         auto result = refCount() - 1;
164         deref();
165         return result ? rtc::RefCountReleaseStatus::kOtherRefsRemained
166         : rtc::RefCountReleaseStatus::kDroppedLastRef;
167     }
168
169     std::pair<LibWebRTCRtpSenderBackend::Source, rtc::scoped_refptr<webrtc::MediaStreamTrackInterface>> createSourceAndRTCTrack(MediaStreamTrack&);
170
171 #if !RELEASE_LOG_DISABLED
172     const Logger& logger() const final { return m_logger.get(); }
173     const void* logIdentifier() const final { return m_logIdentifier; }
174     const char* logClassName() const final { return "LibWebRTCMediaEndpoint"; }
175     WTFLogChannel& logChannel() const final;
176
177     Seconds statsLogInterval(int64_t) const;
178 #endif
179
180     LibWebRTCPeerConnectionBackend& m_peerConnectionBackend;
181     webrtc::PeerConnectionFactoryInterface& m_peerConnectionFactory;
182     rtc::scoped_refptr<webrtc::PeerConnectionInterface> m_backend;
183
184     friend CreateSessionDescriptionObserver<LibWebRTCMediaEndpoint>;
185     friend SetLocalSessionDescriptionObserver<LibWebRTCMediaEndpoint>;
186     friend SetRemoteSessionDescriptionObserver<LibWebRTCMediaEndpoint>;
187
188     CreateSessionDescriptionObserver<LibWebRTCMediaEndpoint> m_createSessionDescriptionObserver;
189     SetLocalSessionDescriptionObserver<LibWebRTCMediaEndpoint> m_setLocalSessionDescriptionObserver;
190     SetRemoteSessionDescriptionObserver<LibWebRTCMediaEndpoint> m_setRemoteSessionDescriptionObserver;
191
192     HashMap<String, RefPtr<MediaStream>> m_remoteStreamsById;
193     HashMap<MediaStreamTrack*, Vector<String>> m_remoteStreamsFromRemoteTrack;
194
195     bool m_isInitiator { false };
196     Timer m_statsLogTimer;
197
198     HashMap<String, rtc::scoped_refptr<webrtc::MediaStreamInterface>> m_localStreams;
199
200 #if !RELEASE_LOG_DISABLED
201     int64_t m_statsFirstDeliveredTimestamp { 0 };
202     Ref<const Logger> m_logger;
203     const void* m_logIdentifier;
204 #endif
205 };
206
207 } // namespace WebCore
208
209 #endif // USE(LIBWEBRTC)