Make sure LibWebRTCMediaEndpoint is always destroyed on the main thread
[WebKit-https.git] / Source / WebCore / Modules / mediastream / libwebrtc / LibWebRTCMediaEndpoint.h
1 /*
2  * Copyright (C) 2017 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 "LibWebRTCProvider.h"
30 #include "PeerConnectionBackend.h"
31 #include "RTCRtpReceiver.h"
32 #include "RealtimeOutgoingAudioSource.h"
33 #include "RealtimeOutgoingVideoSource.h"
34 #include <Timer.h>
35 #include <webrtc/api/jsep.h>
36 #include <webrtc/api/peerconnectioninterface.h>
37 #include <webrtc/pc/peerconnectionfactory.h>
38 #include <webrtc/pc/rtcstatscollector.h>
39 #include <wtf/LoggerHelper.h>
40 #include <wtf/ThreadSafeRefCounted.h>
41
42 namespace webrtc {
43 class CreateSessionDescriptionObserver;
44 class DataChannelInterface;
45 class IceCandidateInterface;
46 class MediaStreamInterface;
47 class PeerConnectionObserver;
48 class SessionDescriptionInterface;
49 class SetSessionDescriptionObserver;
50 }
51
52 namespace WebCore {
53
54 class LibWebRTCProvider;
55 class LibWebRTCPeerConnectionBackend;
56 class MediaStreamTrack;
57 class RTCSessionDescription;
58
59 class LibWebRTCMediaEndpoint
60     : public ThreadSafeRefCounted<LibWebRTCMediaEndpoint, WTF::DestructionThread::Main>
61     , private webrtc::PeerConnectionObserver
62     , private webrtc::RTCStatsCollectorCallback
63 #if !RELEASE_LOG_DISABLED
64     , private LoggerHelper
65 #endif
66 {
67 public:
68     static Ref<LibWebRTCMediaEndpoint> create(LibWebRTCPeerConnectionBackend& peerConnection, LibWebRTCProvider& client) { return adoptRef(*new LibWebRTCMediaEndpoint(peerConnection, client)); }
69     virtual ~LibWebRTCMediaEndpoint() = default;
70
71     bool setConfiguration(LibWebRTCProvider&, webrtc::PeerConnectionInterface::RTCConfiguration&&);
72
73     webrtc::PeerConnectionInterface& backend() const { ASSERT(m_backend); return *m_backend.get(); }
74     void doSetLocalDescription(RTCSessionDescription&);
75     void doSetRemoteDescription(RTCSessionDescription&);
76     void doCreateOffer(const RTCOfferOptions&);
77     void doCreateAnswer();
78     void getStats(MediaStreamTrack*, const DeferredPromise&);
79     std::unique_ptr<RTCDataChannelHandler> createDataChannel(const String&, const RTCDataChannelInit&);
80     bool addIceCandidate(webrtc::IceCandidateInterface& candidate) { return m_backend->AddIceCandidate(&candidate); }
81
82     void stop();
83     bool isStopped() const { return !m_backend; }
84
85     RefPtr<RTCSessionDescription> localDescription() const;
86     RefPtr<RTCSessionDescription> remoteDescription() const;
87     RefPtr<RTCSessionDescription> currentLocalDescription() const;
88     RefPtr<RTCSessionDescription> currentRemoteDescription() const;
89     RefPtr<RTCSessionDescription> pendingLocalDescription() const;
90     RefPtr<RTCSessionDescription> pendingRemoteDescription() const;
91
92     void addTrack(RTCRtpSender&, MediaStreamTrack&, const Vector<String>&);
93     void removeTrack(RTCRtpSender&);
94     RTCRtpParameters getRTCRtpSenderParameters(RTCRtpSender&);
95
96 private:
97     LibWebRTCMediaEndpoint(LibWebRTCPeerConnectionBackend&, LibWebRTCProvider&);
98
99     // webrtc::PeerConnectionObserver API
100     void OnSignalingChange(webrtc::PeerConnectionInterface::SignalingState) final;
101     void OnAddStream(rtc::scoped_refptr<webrtc::MediaStreamInterface>) final;
102     void OnRemoveStream(rtc::scoped_refptr<webrtc::MediaStreamInterface>) final;
103     void OnDataChannel(rtc::scoped_refptr<webrtc::DataChannelInterface>) final;
104     void OnAddTrack(rtc::scoped_refptr<webrtc::RtpReceiverInterface>, const std::vector<rtc::scoped_refptr<webrtc::MediaStreamInterface>>&) final;
105     void OnRenegotiationNeeded() final;
106     void OnIceConnectionChange(webrtc::PeerConnectionInterface::IceConnectionState) final;
107     void OnIceGatheringChange(webrtc::PeerConnectionInterface::IceGatheringState) final;
108     void OnIceCandidate(const webrtc::IceCandidateInterface*) final;
109     void OnIceCandidatesRemoved(const std::vector<cricket::Candidate>&) final;
110
111     void createSessionDescriptionSucceeded(std::unique_ptr<webrtc::SessionDescriptionInterface>&&);
112     void createSessionDescriptionFailed(const std::string&);
113     void setLocalSessionDescriptionSucceeded();
114     void setLocalSessionDescriptionFailed(const std::string&);
115     void setRemoteSessionDescriptionSucceeded();
116     void setRemoteSessionDescriptionFailed(const std::string&);
117     void addRemoteStream(webrtc::MediaStreamInterface&);
118     void addRemoteTrack(rtc::scoped_refptr<webrtc::RtpReceiverInterface>&&, const std::vector<rtc::scoped_refptr<webrtc::MediaStreamInterface>>&);
119     void removeRemoteStream(webrtc::MediaStreamInterface&);
120     void addDataChannel(rtc::scoped_refptr<webrtc::DataChannelInterface>&&);
121
122     void OnStatsDelivered(const rtc::scoped_refptr<const webrtc::RTCStatsReport>&) final;
123     void gatherStatsForLogging();
124     void startLoggingStats();
125     void stopLoggingStats();
126
127     MediaStream& mediaStreamFromRTCStream(webrtc::MediaStreamInterface&);
128
129     void AddRef() const { ref(); }
130     rtc::RefCountReleaseStatus Release() const
131     {
132         deref();
133         return refCount() ? rtc::RefCountReleaseStatus::kDroppedLastRef : rtc::RefCountReleaseStatus::kOtherRefsRemained;
134     }
135
136     bool shouldOfferAllowToReceiveAudio() const;
137     bool shouldOfferAllowToReceiveVideo() const;
138
139 #if !RELEASE_LOG_DISABLED
140     const Logger& logger() const final { return m_logger.get(); }
141     const void* logIdentifier() const final { return m_logIdentifier; }
142     const char* logClassName() const final { return "LibWebRTCMediaEndpoint"; }
143     WTFLogChannel& logChannel() const final;
144
145     Seconds statsLogInterval(int64_t) const;
146 #endif
147
148     class CreateSessionDescriptionObserver final : public webrtc::CreateSessionDescriptionObserver {
149     public:
150         explicit CreateSessionDescriptionObserver(LibWebRTCMediaEndpoint &endpoint) : m_endpoint(endpoint) { }
151
152         void OnSuccess(webrtc::SessionDescriptionInterface* sessionDescription) final { m_endpoint.createSessionDescriptionSucceeded(std::unique_ptr<webrtc::SessionDescriptionInterface>(sessionDescription)); }
153         void OnFailure(const std::string& error) final { m_endpoint.createSessionDescriptionFailed(error); }
154
155         void AddRef() const { m_endpoint.AddRef(); }
156         rtc::RefCountReleaseStatus Release() const { return m_endpoint.Release(); }
157
158     private:
159         LibWebRTCMediaEndpoint& m_endpoint;
160     };
161
162     class SetLocalSessionDescriptionObserver final : public webrtc::SetSessionDescriptionObserver {
163     public:
164         explicit SetLocalSessionDescriptionObserver(LibWebRTCMediaEndpoint &endpoint) : m_endpoint(endpoint) { }
165
166         void OnSuccess() final { m_endpoint.setLocalSessionDescriptionSucceeded(); }
167         void OnFailure(const std::string& error) final { m_endpoint.setLocalSessionDescriptionFailed(error); }
168
169         void AddRef() const { m_endpoint.AddRef(); }
170         rtc::RefCountReleaseStatus Release() const { return m_endpoint.Release(); }
171
172     private:
173         LibWebRTCMediaEndpoint& m_endpoint;
174     };
175
176     class SetRemoteSessionDescriptionObserver final : public webrtc::SetSessionDescriptionObserver {
177     public:
178         explicit SetRemoteSessionDescriptionObserver(LibWebRTCMediaEndpoint &endpoint) : m_endpoint(endpoint) { }
179
180         void OnSuccess() final { m_endpoint.setRemoteSessionDescriptionSucceeded(); }
181         void OnFailure(const std::string& error) final { m_endpoint.setRemoteSessionDescriptionFailed(error); }
182
183         void AddRef() const { m_endpoint.AddRef(); }
184         rtc::RefCountReleaseStatus Release() const { return m_endpoint.Release(); }
185
186     private:
187         LibWebRTCMediaEndpoint& m_endpoint;
188     };
189
190     class StatsCollector : public webrtc::RTCStatsCollectorCallback {
191     public:
192         static rtc::scoped_refptr<StatsCollector> create(Ref<LibWebRTCMediaEndpoint>&& endpoint, const DeferredPromise& promise, MediaStreamTrack* track) { return new rtc::RefCountedObject<StatsCollector>(WTFMove(endpoint), promise, track); }
193
194         StatsCollector(Ref<LibWebRTCMediaEndpoint>&&, const DeferredPromise&, MediaStreamTrack*);
195
196     private:
197         void OnStatsDelivered(const rtc::scoped_refptr<const webrtc::RTCStatsReport>&) final;
198
199         Ref<LibWebRTCMediaEndpoint> m_endpoint;
200         const DeferredPromise& m_promise;
201         String m_id;
202     };
203
204     LibWebRTCPeerConnectionBackend& m_peerConnectionBackend;
205     webrtc::PeerConnectionFactoryInterface& m_peerConnectionFactory;
206     rtc::scoped_refptr<webrtc::PeerConnectionInterface> m_backend;
207
208     CreateSessionDescriptionObserver m_createSessionDescriptionObserver;
209     SetLocalSessionDescriptionObserver m_setLocalSessionDescriptionObserver;
210     SetRemoteSessionDescriptionObserver m_setRemoteSessionDescriptionObserver;
211     HashMap<webrtc::MediaStreamInterface*, MediaStream*> m_streams;
212     HashMap<RTCRtpSender*, rtc::scoped_refptr<webrtc::RtpSenderInterface>> m_senders;
213
214     bool m_isInitiator { false };
215     Timer m_statsLogTimer;
216
217 #if !RELEASE_LOG_DISABLED
218     int64_t m_statsFirstDeliveredTimestamp { 0 };
219     Ref<const Logger> m_logger;
220     const void* m_logIdentifier;
221 #endif
222 };
223
224 } // namespace WebCore
225
226 #endif // USE(LIBWEBRTC)