blob: a67780b7963bb6505bc74490bea4d6d3a7cb1b3f [file] [log] [blame]
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001/*
kjellanderb24317b2016-02-10 07:54:43 -08002 * Copyright 2012 The WebRTC project authors. All Rights Reserved.
henrike@webrtc.org28e20752013-07-10 00:45:36 +00003 *
kjellanderb24317b2016-02-10 07:54:43 -08004 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
henrike@webrtc.org28e20752013-07-10 00:45:36 +00009 */
10
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020011#ifndef PC_PEERCONNECTION_H_
12#define PC_PEERCONNECTION_H_
henrike@webrtc.org28e20752013-07-10 00:45:36 +000013
perkjd61bf802016-03-24 03:16:19 -070014#include <map>
kwibergd1fe2812016-04-27 06:47:29 -070015#include <memory>
Steve Anton75737c02017-11-06 10:37:17 -080016#include <set>
17#include <string>
perkjd61bf802016-03-24 03:16:19 -070018#include <vector>
henrike@webrtc.org28e20752013-07-10 00:45:36 +000019
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020020#include "api/peerconnectioninterface.h"
Jonas Orelandbdcee282017-10-10 14:01:40 +020021#include "api/turncustomizer.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020022#include "pc/iceserverparsing.h"
23#include "pc/peerconnectionfactory.h"
24#include "pc/rtcstatscollector.h"
Steve Anton4171afb2017-11-20 10:20:22 -080025#include "pc/rtptransceiver.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020026#include "pc/statscollector.h"
27#include "pc/streamcollection.h"
Steve Anton75737c02017-11-06 10:37:17 -080028#include "pc/webrtcsessiondescriptionfactory.h"
henrike@webrtc.org28e20752013-07-10 00:45:36 +000029
30namespace webrtc {
henrike@webrtc.org28e20752013-07-10 00:45:36 +000031
deadbeefeb459812015-12-15 19:24:43 -080032class MediaStreamObserver;
perkjf0dcfe22016-03-10 18:32:00 +010033class VideoRtpReceiver;
skvlad11a9cbf2016-10-07 11:53:05 -070034class RtcEventLog;
deadbeefab9b2d12015-10-14 11:33:11 -070035
Steve Anton75737c02017-11-06 10:37:17 -080036// Statistics for all the transports of the session.
37// TODO(pthatcher): Think of a better name for this. We already have
38// a TransportStats in transport.h. Perhaps TransportsStats?
39struct SessionStats {
40 std::map<std::string, std::string> proxy_to_transport;
41 std::map<std::string, cricket::TransportStats> transport_stats;
42};
Steve Antonba818672017-11-06 10:21:57 -080043
Steve Anton75737c02017-11-06 10:37:17 -080044struct ChannelNamePair {
45 ChannelNamePair(const std::string& content_name,
46 const std::string& transport_name)
47 : content_name(content_name), transport_name(transport_name) {}
48 std::string content_name;
49 std::string transport_name;
50};
51
52struct ChannelNamePairs {
53 rtc::Optional<ChannelNamePair> voice;
54 rtc::Optional<ChannelNamePair> video;
55 rtc::Optional<ChannelNamePair> data;
56};
57
58// PeerConnection is the implementation of the PeerConnection object as defined
59// by the PeerConnectionInterface API surface.
60// The class currently is solely responsible for the following:
61// - Managing the session state machine (signaling state).
62// - Creating and initializing lower-level objects, like PortAllocator and
63// BaseChannels.
64// - Owning and managing the life cycle of the RtpSender/RtpReceiver and track
65// objects.
66// - Tracking the current and pending local/remote session descriptions.
67// The class currently is jointly responsible for the following:
68// - Parsing and interpreting SDP.
69// - Generating offers and answers based on the current state.
70// - The ICE state machine.
71// - Generating stats.
henrike@webrtc.org28e20752013-07-10 00:45:36 +000072class PeerConnection : public PeerConnectionInterface,
Steve Anton75737c02017-11-06 10:37:17 -080073 public DataChannelProviderInterface,
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +000074 public rtc::MessageHandler,
henrike@webrtc.org28e20752013-07-10 00:45:36 +000075 public sigslot::has_slots<> {
76 public:
zhihuang38ede132017-06-15 12:52:32 -070077 explicit PeerConnection(PeerConnectionFactory* factory,
78 std::unique_ptr<RtcEventLog> event_log,
79 std::unique_ptr<Call> call);
henrike@webrtc.org28e20752013-07-10 00:45:36 +000080
deadbeef653b8e02015-11-11 12:55:10 -080081 bool Initialize(
82 const PeerConnectionInterface::RTCConfiguration& configuration,
kwibergd1fe2812016-04-27 06:47:29 -070083 std::unique_ptr<cricket::PortAllocator> allocator,
Henrik Boströmd03c23b2016-06-01 11:44:18 +020084 std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator,
deadbeef653b8e02015-11-11 12:55:10 -080085 PeerConnectionObserver* observer);
86
deadbeefa67696b2015-09-29 11:56:26 -070087 rtc::scoped_refptr<StreamCollectionInterface> local_streams() override;
88 rtc::scoped_refptr<StreamCollectionInterface> remote_streams() override;
89 bool AddStream(MediaStreamInterface* local_stream) override;
90 void RemoveStream(MediaStreamInterface* local_stream) override;
henrike@webrtc.org28e20752013-07-10 00:45:36 +000091
deadbeefe1f9d832016-01-14 15:35:42 -080092 rtc::scoped_refptr<RtpSenderInterface> AddTrack(
93 MediaStreamTrackInterface* track,
94 std::vector<MediaStreamInterface*> streams) override;
95 bool RemoveTrack(RtpSenderInterface* sender) override;
96
Steve Anton8c0f7a72017-10-03 10:03:10 -070097 // Gets the DTLS SSL certificate associated with the audio transport on the
98 // remote side. This will become populated once the DTLS connection with the
99 // peer has been completed, as indicated by the ICE connection state
100 // transitioning to kIceConnectionCompleted.
101 // Note that this will be removed once we implement RTCDtlsTransport which
102 // has standardized method for getting this information.
103 // See https://www.w3.org/TR/webrtc/#rtcdtlstransport-interface
104 std::unique_ptr<rtc::SSLCertificate> GetRemoteAudioSSLCertificate();
105
deadbeefa67696b2015-09-29 11:56:26 -0700106 rtc::scoped_refptr<DtmfSenderInterface> CreateDtmfSender(
107 AudioTrackInterface* track) override;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000108
deadbeeffac06552015-11-25 11:26:01 -0800109 rtc::scoped_refptr<RtpSenderInterface> CreateSender(
deadbeefbd7d8f72015-12-18 16:58:44 -0800110 const std::string& kind,
111 const std::string& stream_id) override;
deadbeeffac06552015-11-25 11:26:01 -0800112
deadbeef70ab1a12015-09-28 16:53:55 -0700113 std::vector<rtc::scoped_refptr<RtpSenderInterface>> GetSenders()
114 const override;
115 std::vector<rtc::scoped_refptr<RtpReceiverInterface>> GetReceivers()
116 const override;
117
deadbeefa67696b2015-09-29 11:56:26 -0700118 rtc::scoped_refptr<DataChannelInterface> CreateDataChannel(
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000119 const std::string& label,
deadbeefa67696b2015-09-29 11:56:26 -0700120 const DataChannelInit* config) override;
121 bool GetStats(StatsObserver* observer,
122 webrtc::MediaStreamTrackInterface* track,
123 StatsOutputLevel level) override;
hbos74e1a4f2016-09-15 23:33:01 -0700124 void GetStats(RTCStatsCollectorCallback* callback) override;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000125
deadbeefa67696b2015-09-29 11:56:26 -0700126 SignalingState signaling_state() override;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000127
deadbeefa67696b2015-09-29 11:56:26 -0700128 IceConnectionState ice_connection_state() override;
129 IceGatheringState ice_gathering_state() override;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000130
deadbeefa67696b2015-09-29 11:56:26 -0700131 const SessionDescriptionInterface* local_description() const override;
132 const SessionDescriptionInterface* remote_description() const override;
deadbeeffe4a8a42016-12-20 17:56:17 -0800133 const SessionDescriptionInterface* current_local_description() const override;
134 const SessionDescriptionInterface* current_remote_description()
135 const override;
136 const SessionDescriptionInterface* pending_local_description() const override;
137 const SessionDescriptionInterface* pending_remote_description()
138 const override;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000139
140 // JSEP01
htaa2a49d92016-03-04 02:51:39 -0800141 // Deprecated, use version without constraints.
deadbeefa67696b2015-09-29 11:56:26 -0700142 void CreateOffer(CreateSessionDescriptionObserver* observer,
143 const MediaConstraintsInterface* constraints) override;
144 void CreateOffer(CreateSessionDescriptionObserver* observer,
145 const RTCOfferAnswerOptions& options) override;
htaa2a49d92016-03-04 02:51:39 -0800146 // Deprecated, use version without constraints.
deadbeefa67696b2015-09-29 11:56:26 -0700147 void CreateAnswer(CreateSessionDescriptionObserver* observer,
148 const MediaConstraintsInterface* constraints) override;
htaa2a49d92016-03-04 02:51:39 -0800149 void CreateAnswer(CreateSessionDescriptionObserver* observer,
150 const RTCOfferAnswerOptions& options) override;
deadbeefa67696b2015-09-29 11:56:26 -0700151 void SetLocalDescription(SetSessionDescriptionObserver* observer,
152 SessionDescriptionInterface* desc) override;
Henrik Boström6c7ec322017-11-22 17:43:47 +0100153 void SetRemoteDescription(
154 std::unique_ptr<SessionDescriptionInterface> desc,
155 rtc::scoped_refptr<SetRemoteDescriptionObserverInterface> observer)
156 override;
deadbeef46c73892016-11-16 19:42:04 -0800157 PeerConnectionInterface::RTCConfiguration GetConfiguration() override;
deadbeefa67696b2015-09-29 11:56:26 -0700158 bool SetConfiguration(
deadbeef293e9262017-01-11 12:28:30 -0800159 const PeerConnectionInterface::RTCConfiguration& configuration,
160 RTCError* error) override;
161 bool SetConfiguration(
162 const PeerConnectionInterface::RTCConfiguration& configuration) override {
163 return SetConfiguration(configuration, nullptr);
164 }
deadbeefa67696b2015-09-29 11:56:26 -0700165 bool AddIceCandidate(const IceCandidateInterface* candidate) override;
Honghai Zhang7fb69db2016-03-14 11:59:18 -0700166 bool RemoveIceCandidates(
167 const std::vector<cricket::Candidate>& candidates) override;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000168
deadbeefa67696b2015-09-29 11:56:26 -0700169 void RegisterUMAObserver(UMAObserver* observer) override;
buildbot@webrtc.org1567b8c2014-05-08 19:54:16 +0000170
zstein4b979802017-06-02 14:37:37 -0700171 RTCError SetBitrate(const BitrateParameters& bitrate) override;
172
Alex Narest78609d52017-10-20 10:37:47 +0200173 void SetBitrateAllocationStrategy(
174 std::unique_ptr<rtc::BitrateAllocationStrategy>
175 bitrate_allocation_strategy) override;
176
henrika5f6bf242017-11-01 11:06:56 +0100177 void SetAudioPlayout(bool playout) override;
178 void SetAudioRecording(bool recording) override;
179
Elad Alon99c3fe52017-10-13 16:29:40 +0200180 RTC_DEPRECATED bool StartRtcEventLog(rtc::PlatformFile file,
181 int64_t max_size_bytes) override;
Bjorn Tereliusde939432017-11-20 17:38:14 +0100182 bool StartRtcEventLog(std::unique_ptr<RtcEventLogOutput> output,
183 int64_t output_period_ms) override;
ivoc14d5dbe2016-07-04 07:06:55 -0700184 void StopRtcEventLog() override;
185
deadbeefa67696b2015-09-29 11:56:26 -0700186 void Close() override;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000187
hbos82ebe022016-11-14 01:41:09 -0800188 sigslot::signal1<DataChannel*> SignalDataChannelCreated;
189
deadbeefab9b2d12015-10-14 11:33:11 -0700190 // Virtual for unit tests.
191 virtual const std::vector<rtc::scoped_refptr<DataChannel>>&
192 sctp_data_channels() const {
193 return sctp_data_channels_;
perkjd61bf802016-03-24 03:16:19 -0700194 }
deadbeefab9b2d12015-10-14 11:33:11 -0700195
Steve Anton978b8762017-09-29 12:15:02 -0700196 rtc::Thread* network_thread() const { return factory_->network_thread(); }
197 rtc::Thread* worker_thread() const { return factory_->worker_thread(); }
198 rtc::Thread* signaling_thread() const { return factory_->signaling_thread(); }
Steve Anton75737c02017-11-06 10:37:17 -0800199
200 // The SDP session ID as defined by RFC 3264.
201 virtual const std::string& session_id() const { return session_id_; }
202
203 // Returns true if we were the initial offerer.
204 bool initial_offerer() const { return initial_offerer_ && *initial_offerer_; }
205
206 // Returns stats for all channels of all transports.
207 // This avoids exposing the internal structures used to track them.
208 // The parameterless version creates |ChannelNamePairs| from |voice_channel|,
209 // |video_channel| and |voice_channel| if available - this requires it to be
210 // called on the signaling thread - and invokes the other |GetStats|. The
211 // other |GetStats| can be invoked on any thread; if not invoked on the
212 // network thread a thread hop will happen.
213 std::unique_ptr<SessionStats> GetSessionStats_s();
Steve Anton978b8762017-09-29 12:15:02 -0700214 virtual std::unique_ptr<SessionStats> GetSessionStats(
Steve Anton75737c02017-11-06 10:37:17 -0800215 const ChannelNamePairs& channel_name_pairs);
216
217 // virtual so it can be mocked in unit tests
Steve Anton978b8762017-09-29 12:15:02 -0700218 virtual bool GetLocalCertificate(
219 const std::string& transport_name,
Steve Anton75737c02017-11-06 10:37:17 -0800220 rtc::scoped_refptr<rtc::RTCCertificate>* certificate);
Steve Anton978b8762017-09-29 12:15:02 -0700221 virtual std::unique_ptr<rtc::SSLCertificate> GetRemoteSSLCertificate(
Steve Anton75737c02017-11-06 10:37:17 -0800222 const std::string& transport_name);
223
224 virtual Call::Stats GetCallStats();
225
226 // Exposed for stats collecting.
227 // TODO(steveanton): Switch callers to use the plural form and remove these.
Steve Anton4171afb2017-11-20 10:20:22 -0800228 virtual cricket::VoiceChannel* voice_channel() const {
229 return static_cast<cricket::VoiceChannel*>(
230 GetAudioTransceiver()->internal()->channel());
Steve Anton978b8762017-09-29 12:15:02 -0700231 }
Steve Anton4171afb2017-11-20 10:20:22 -0800232 virtual cricket::VideoChannel* video_channel() const {
233 return static_cast<cricket::VideoChannel*>(
234 GetVideoTransceiver()->internal()->channel());
Steve Antond5585ca2017-10-23 14:49:26 -0700235 }
Steve Anton978b8762017-09-29 12:15:02 -0700236
Steve Anton75737c02017-11-06 10:37:17 -0800237 // Only valid when using deprecated RTP data channels.
238 virtual cricket::RtpDataChannel* rtp_data_channel() {
239 return rtp_data_channel_;
Steve Anton978b8762017-09-29 12:15:02 -0700240 }
Steve Anton75737c02017-11-06 10:37:17 -0800241 virtual rtc::Optional<std::string> sctp_content_name() const {
242 return sctp_content_name_;
243 }
244 virtual rtc::Optional<std::string> sctp_transport_name() const {
245 return sctp_transport_name_;
246 }
247
248 // Get the id used as a media stream track's "id" field from ssrc.
249 virtual bool GetLocalTrackIdBySsrc(uint32_t ssrc, std::string* track_id);
250 virtual bool GetRemoteTrackIdBySsrc(uint32_t ssrc, std::string* track_id);
251
252 // Returns true if there was an ICE restart initiated by the remote offer.
253 bool IceRestartPending(const std::string& content_name) const;
254
255 // Returns true if the ICE restart flag above was set, and no ICE restart has
256 // occurred yet for this transport (by applying a local description with
257 // changed ufrag/password). If the transport has been deleted as a result of
258 // bundling, returns false.
259 bool NeedsIceRestart(const std::string& content_name) const;
260
261 // Get SSL role for an arbitrary m= section (handles bundling correctly).
262 // TODO(deadbeef): This is only used internally by the session description
263 // factory, it shouldn't really be public).
264 bool GetSslRole(const std::string& content_name, rtc::SSLRole* role);
265
266 enum Error {
267 ERROR_NONE = 0, // no error
268 ERROR_CONTENT = 1, // channel errors in SetLocalContent/SetRemoteContent
269 ERROR_TRANSPORT = 2, // transport error of some kind
270 };
Steve Anton978b8762017-09-29 12:15:02 -0700271
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000272 protected:
deadbeefa67696b2015-09-29 11:56:26 -0700273 ~PeerConnection() override;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000274
275 private:
Steve Anton4171afb2017-11-20 10:20:22 -0800276 struct RtpSenderInfo {
277 RtpSenderInfo() : first_ssrc(0) {}
278 RtpSenderInfo(const std::string& stream_label,
279 const std::string sender_id,
280 uint32_t ssrc)
281 : stream_label(stream_label), sender_id(sender_id), first_ssrc(ssrc) {}
282 bool operator==(const RtpSenderInfo& other) {
deadbeefbda7e0b2015-12-08 17:13:40 -0800283 return this->stream_label == other.stream_label &&
Steve Anton4171afb2017-11-20 10:20:22 -0800284 this->sender_id == other.sender_id &&
285 this->first_ssrc == other.first_ssrc;
deadbeefbda7e0b2015-12-08 17:13:40 -0800286 }
deadbeefab9b2d12015-10-14 11:33:11 -0700287 std::string stream_label;
Steve Anton4171afb2017-11-20 10:20:22 -0800288 std::string sender_id;
289 // An RtpSender can have many SSRCs. The first one is used as a sort of ID
290 // for communicating with the lower layers.
291 uint32_t first_ssrc;
deadbeefab9b2d12015-10-14 11:33:11 -0700292 };
deadbeefab9b2d12015-10-14 11:33:11 -0700293
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000294 // Implements MessageHandler.
deadbeefa67696b2015-09-29 11:56:26 -0700295 void OnMessage(rtc::Message* msg) override;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000296
Steve Anton4171afb2017-11-20 10:20:22 -0800297 std::vector<rtc::scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>>>
298 GetSendersInternal() const;
299 std::vector<
300 rtc::scoped_refptr<RtpReceiverProxyWithInternal<RtpReceiverInternal>>>
301 GetReceiversInternal() const;
302
303 rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>
304 GetAudioTransceiver() const;
305 rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>
306 GetVideoTransceiver() const;
307
deadbeefab9b2d12015-10-14 11:33:11 -0700308 void CreateAudioReceiver(MediaStreamInterface* stream,
Steve Anton4171afb2017-11-20 10:20:22 -0800309 const RtpSenderInfo& remote_sender_info);
perkjf0dcfe22016-03-10 18:32:00 +0100310
deadbeefab9b2d12015-10-14 11:33:11 -0700311 void CreateVideoReceiver(MediaStreamInterface* stream,
Steve Anton4171afb2017-11-20 10:20:22 -0800312 const RtpSenderInfo& remote_sender_info);
Henrik Boström933d8b02017-10-10 10:05:16 -0700313 rtc::scoped_refptr<RtpReceiverInterface> RemoveAndStopReceiver(
Steve Anton4171afb2017-11-20 10:20:22 -0800314 const RtpSenderInfo& remote_sender_info);
korniltsev.anatolyec390b52017-07-24 17:00:25 -0700315
316 // May be called either by AddStream/RemoveStream, or when a track is
317 // added/removed from a stream previously added via AddStream.
318 void AddAudioTrack(AudioTrackInterface* track, MediaStreamInterface* stream);
319 void RemoveAudioTrack(AudioTrackInterface* track,
320 MediaStreamInterface* stream);
321 void AddVideoTrack(VideoTrackInterface* track, MediaStreamInterface* stream);
322 void RemoveVideoTrack(VideoTrackInterface* track,
323 MediaStreamInterface* stream);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000324
Steve Antonba818672017-11-06 10:21:57 -0800325 void SetIceConnectionState(IceConnectionState new_state);
326 // Called any time the IceGatheringState changes
327 void OnIceGatheringChange(IceGatheringState new_state);
328 // New ICE candidate has been gathered.
329 void OnIceCandidate(std::unique_ptr<IceCandidateInterface> candidate);
330 // Some local ICE candidates have been removed.
Honghai Zhang7fb69db2016-03-14 11:59:18 -0700331 void OnIceCandidatesRemoved(
Steve Antonba818672017-11-06 10:21:57 -0800332 const std::vector<cricket::Candidate>& candidates);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000333
Steve Antonba818672017-11-06 10:21:57 -0800334 // Update the state, signaling if necessary.
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000335 void ChangeSignalingState(SignalingState signaling_state);
336
deadbeefeb459812015-12-15 19:24:43 -0800337 // Signals from MediaStreamObserver.
338 void OnAudioTrackAdded(AudioTrackInterface* track,
339 MediaStreamInterface* stream);
340 void OnAudioTrackRemoved(AudioTrackInterface* track,
341 MediaStreamInterface* stream);
342 void OnVideoTrackAdded(VideoTrackInterface* track,
343 MediaStreamInterface* stream);
344 void OnVideoTrackRemoved(VideoTrackInterface* track,
345 MediaStreamInterface* stream);
346
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000347 void PostSetSessionDescriptionFailure(SetSessionDescriptionObserver* observer,
348 const std::string& error);
deadbeefab9b2d12015-10-14 11:33:11 -0700349 void PostCreateSessionDescriptionFailure(
350 CreateSessionDescriptionObserver* observer,
351 const std::string& error);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000352
353 bool IsClosed() const {
354 return signaling_state_ == PeerConnectionInterface::kClosed;
355 }
356
deadbeefab9b2d12015-10-14 11:33:11 -0700357 // Returns a MediaSessionOptions struct with options decided by |options|,
358 // the local MediaStreams and DataChannels.
zhihuang1c378ed2017-08-17 14:10:50 -0700359 void GetOptionsForOffer(
deadbeefab9b2d12015-10-14 11:33:11 -0700360 const PeerConnectionInterface::RTCOfferAnswerOptions& rtc_options,
361 cricket::MediaSessionOptions* session_options);
362
363 // Returns a MediaSessionOptions struct with options decided by
364 // |constraints|, the local MediaStreams and DataChannels.
zhihuang1c378ed2017-08-17 14:10:50 -0700365 void GetOptionsForAnswer(const RTCOfferAnswerOptions& options,
366 cricket::MediaSessionOptions* session_options);
htaa2a49d92016-03-04 02:51:39 -0800367
zhihuang1c378ed2017-08-17 14:10:50 -0700368 // Generates MediaDescriptionOptions for the |session_opts| based on existing
369 // local description or remote description.
370 void GenerateMediaDescriptionOptions(
371 const SessionDescriptionInterface* session_desc,
372 cricket::RtpTransceiverDirection audio_direction,
373 cricket::RtpTransceiverDirection video_direction,
374 rtc::Optional<size_t>* audio_index,
375 rtc::Optional<size_t>* video_index,
376 rtc::Optional<size_t>* data_index,
htaa2a49d92016-03-04 02:51:39 -0800377 cricket::MediaSessionOptions* session_options);
deadbeefab9b2d12015-10-14 11:33:11 -0700378
Steve Anton4171afb2017-11-20 10:20:22 -0800379 // Remove all local and remote senders of type |media_type|.
deadbeeffaac4972015-11-12 15:33:07 -0800380 // Called when a media type is rejected (m-line set to port 0).
Steve Anton4171afb2017-11-20 10:20:22 -0800381 void RemoveSenders(cricket::MediaType media_type);
deadbeeffaac4972015-11-12 15:33:07 -0800382
deadbeefbda7e0b2015-12-08 17:13:40 -0800383 // Makes sure a MediaStreamTrack is created for each StreamParam in |streams|,
384 // and existing MediaStreamTracks are removed if there is no corresponding
385 // StreamParam. If |default_track_needed| is true, a default MediaStreamTrack
386 // is created if it doesn't exist; if false, it's removed if it exists.
387 // |media_type| is the type of the |streams| and can be either audio or video.
deadbeefab9b2d12015-10-14 11:33:11 -0700388 // If a new MediaStream is created it is added to |new_streams|.
Steve Anton4171afb2017-11-20 10:20:22 -0800389 void UpdateRemoteSendersList(
deadbeefab9b2d12015-10-14 11:33:11 -0700390 const std::vector<cricket::StreamParams>& streams,
deadbeefbda7e0b2015-12-08 17:13:40 -0800391 bool default_track_needed,
deadbeefab9b2d12015-10-14 11:33:11 -0700392 cricket::MediaType media_type,
393 StreamCollection* new_streams);
394
Steve Anton4171afb2017-11-20 10:20:22 -0800395 // Triggered when a remote sender has been seen for the first time in a remote
deadbeefab9b2d12015-10-14 11:33:11 -0700396 // session description. It creates a remote MediaStreamTrackInterface
397 // implementation and triggers CreateAudioReceiver or CreateVideoReceiver.
Steve Anton4171afb2017-11-20 10:20:22 -0800398 void OnRemoteSenderAdded(const RtpSenderInfo& sender_info,
399 cricket::MediaType media_type);
deadbeefab9b2d12015-10-14 11:33:11 -0700400
Steve Anton4171afb2017-11-20 10:20:22 -0800401 // Triggered when a remote sender has been removed from a remote session
402 // description. It removes the remote sender with id |sender_id| from a remote
deadbeefab9b2d12015-10-14 11:33:11 -0700403 // MediaStream and triggers DestroyAudioReceiver or DestroyVideoReceiver.
Steve Anton4171afb2017-11-20 10:20:22 -0800404 void OnRemoteSenderRemoved(const RtpSenderInfo& sender_info,
405 cricket::MediaType media_type);
deadbeefab9b2d12015-10-14 11:33:11 -0700406
407 // Finds remote MediaStreams without any tracks and removes them from
408 // |remote_streams_| and notifies the observer that the MediaStreams no longer
409 // exist.
410 void UpdateEndedRemoteMediaStreams();
411
deadbeefab9b2d12015-10-14 11:33:11 -0700412 // Loops through the vector of |streams| and finds added and removed
413 // StreamParams since last time this method was called.
Steve Anton4171afb2017-11-20 10:20:22 -0800414 // For each new or removed StreamParam, OnLocalSenderSeen or
415 // OnLocalSenderRemoved is invoked.
416 void UpdateLocalSenders(const std::vector<cricket::StreamParams>& streams,
417 cricket::MediaType media_type);
deadbeefab9b2d12015-10-14 11:33:11 -0700418
Steve Anton4171afb2017-11-20 10:20:22 -0800419 // Triggered when a local sender has been seen for the first time in a local
deadbeefab9b2d12015-10-14 11:33:11 -0700420 // session description.
421 // This method triggers CreateAudioSender or CreateVideoSender if the rtp
422 // streams in the local SessionDescription can be mapped to a MediaStreamTrack
423 // in a MediaStream in |local_streams_|
Steve Anton4171afb2017-11-20 10:20:22 -0800424 void OnLocalSenderAdded(const RtpSenderInfo& sender_info,
425 cricket::MediaType media_type);
deadbeefab9b2d12015-10-14 11:33:11 -0700426
Steve Anton4171afb2017-11-20 10:20:22 -0800427 // Triggered when a local sender has been removed from a local session
deadbeefab9b2d12015-10-14 11:33:11 -0700428 // description.
429 // This method triggers DestroyAudioSender or DestroyVideoSender if a stream
430 // has been removed from the local SessionDescription and the stream can be
431 // mapped to a MediaStreamTrack in a MediaStream in |local_streams_|.
Steve Anton4171afb2017-11-20 10:20:22 -0800432 void OnLocalSenderRemoved(const RtpSenderInfo& sender_info,
433 cricket::MediaType media_type);
deadbeefab9b2d12015-10-14 11:33:11 -0700434
435 void UpdateLocalRtpDataChannels(const cricket::StreamParamsVec& streams);
436 void UpdateRemoteRtpDataChannels(const cricket::StreamParamsVec& streams);
437 void UpdateClosingRtpDataChannels(
438 const std::vector<std::string>& active_channels,
439 bool is_local_update);
440 void CreateRemoteRtpDataChannel(const std::string& label,
441 uint32_t remote_ssrc);
442
443 // Creates channel and adds it to the collection of DataChannels that will
444 // be offered in a SessionDescription.
445 rtc::scoped_refptr<DataChannel> InternalCreateDataChannel(
446 const std::string& label,
447 const InternalDataChannelInit* config);
448
449 // Checks if any data channel has been added.
450 bool HasDataChannels() const;
451
452 void AllocateSctpSids(rtc::SSLRole role);
453 void OnSctpDataChannelClosed(DataChannel* channel);
454
deadbeefab9b2d12015-10-14 11:33:11 -0700455 void OnDataChannelDestroyed();
Steve Antonba818672017-11-06 10:21:57 -0800456 // Called when a valid data channel OPEN message is received.
deadbeefab9b2d12015-10-14 11:33:11 -0700457 void OnDataChannelOpenMessage(const std::string& label,
458 const InternalDataChannelInit& config);
459
Steve Anton4171afb2017-11-20 10:20:22 -0800460 // Returns true if the PeerConnection is configured to use Unified Plan
461 // semantics for creating offers/answers and setting local/remote
462 // descriptions. If this is true the RtpTransceiver API will also be available
463 // to the user. If this is false, Plan B semantics are assumed.
Steve Anton79e79602017-11-20 10:25:56 -0800464 // TODO(bugs.webrtc.org/8530): Flip the default to be Unified Plan once
465 // sufficient time has passed.
466 bool IsUnifiedPlan() const {
467 return configuration_.sdp_semantics == SdpSemantics::kUnifiedPlan;
468 }
Steve Anton4171afb2017-11-20 10:20:22 -0800469
470 // Is there an RtpSender of the given type?
zhihuang1c378ed2017-08-17 14:10:50 -0700471 bool HasRtpSender(cricket::MediaType type) const;
deadbeeffac06552015-11-25 11:26:01 -0800472
Steve Anton4171afb2017-11-20 10:20:22 -0800473 // Return the RtpSender with the given track attached.
474 rtc::scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>>
475 FindSenderForTrack(MediaStreamTrackInterface* track) const;
deadbeef70ab1a12015-09-28 16:53:55 -0700476
Steve Anton4171afb2017-11-20 10:20:22 -0800477 // Return the RtpSender with the given id, or null if none exists.
478 rtc::scoped_refptr<RtpSenderProxyWithInternal<RtpSenderInternal>>
479 FindSenderById(const std::string& sender_id) const;
480
481 // Return the RtpReceiver with the given id, or null if none exists.
482 rtc::scoped_refptr<RtpReceiverProxyWithInternal<RtpReceiverInternal>>
483 FindReceiverById(const std::string& receiver_id) const;
484
485 std::vector<RtpSenderInfo>* GetRemoteSenderInfos(
486 cricket::MediaType media_type);
487 std::vector<RtpSenderInfo>* GetLocalSenderInfos(
488 cricket::MediaType media_type);
489 const RtpSenderInfo* FindSenderInfo(const std::vector<RtpSenderInfo>& infos,
490 const std::string& stream_label,
491 const std::string sender_id) const;
deadbeefab9b2d12015-10-14 11:33:11 -0700492
493 // Returns the specified SCTP DataChannel in sctp_data_channels_,
494 // or nullptr if not found.
495 DataChannel* FindDataChannelBySid(int sid) const;
496
Taylor Brandstettera1c30352016-05-13 08:15:11 -0700497 // Called when first configuring the port allocator.
deadbeef91dd5672016-05-18 16:55:30 -0700498 bool InitializePortAllocator_n(const RTCConfiguration& configuration);
deadbeef293e9262017-01-11 12:28:30 -0800499 // Called when SetConfiguration is called to apply the supported subset
500 // of the configuration on the network thread.
501 bool ReconfigurePortAllocator_n(
502 const cricket::ServerAddresses& stun_servers,
503 const std::vector<cricket::RelayServerConfig>& turn_servers,
504 IceTransportsType type,
505 int candidate_pool_size,
Jonas Orelandbdcee282017-10-10 14:01:40 +0200506 bool prune_turn_ports,
507 webrtc::TurnCustomizer* turn_customizer);
Taylor Brandstettera1c30352016-05-13 08:15:11 -0700508
Elad Alon99c3fe52017-10-13 16:29:40 +0200509 // Starts output of an RTC event log to the given output object.
ivoc14d5dbe2016-07-04 07:06:55 -0700510 // This function should only be called from the worker thread.
Bjorn Tereliusde939432017-11-20 17:38:14 +0100511 bool StartRtcEventLog_w(std::unique_ptr<RtcEventLogOutput> output,
512 int64_t output_period_ms);
Elad Alon99c3fe52017-10-13 16:29:40 +0200513
Elad Alonacb24172017-10-06 14:32:13 +0200514 // Stops recording an RTC event log.
ivoc14d5dbe2016-07-04 07:06:55 -0700515 // This function should only be called from the worker thread.
516 void StopRtcEventLog_w();
517
Steve Anton038834f2017-07-14 15:59:59 -0700518 // Ensures the configuration doesn't have any parameters with invalid values,
519 // or values that conflict with other parameters.
520 //
521 // Returns RTCError::OK() if there are no issues.
522 RTCError ValidateConfiguration(const RTCConfiguration& config) const;
523
Steve Antonba818672017-11-06 10:21:57 -0800524 cricket::ChannelManager* channel_manager() const;
525 MetricsObserverInterface* metrics_observer() const;
526
Steve Anton75737c02017-11-06 10:37:17 -0800527 // Indicates the type of SessionDescription in a call to SetLocalDescription
528 // and SetRemoteDescription.
529 enum Action {
530 kOffer,
531 kPrAnswer,
532 kAnswer,
533 };
534
535 // Returns the last error in the session. See the enum above for details.
536 Error error() const { return error_; }
537 const std::string& error_desc() const { return error_desc_; }
538
Steve Anton75737c02017-11-06 10:37:17 -0800539 cricket::BaseChannel* GetChannel(const std::string& content_name);
540
541 // Get current SSL role used by SCTP's underlying transport.
542 bool GetSctpSslRole(rtc::SSLRole* role);
543
Henrik Boström6c7ec322017-11-22 17:43:47 +0100544 // Validates and takes ownership of the description, setting it as the current
545 // or pending description (depending on the description's action) if it is
546 // valid. Also updates ice role, candidates, creates and destroys channels.
547 bool SetCurrentOrPendingLocalDescription(
548 std::unique_ptr<SessionDescriptionInterface> desc,
549 std::string* err_desc);
550 bool SetCurrentOrPendingRemoteDescription(
551 std::unique_ptr<SessionDescriptionInterface> desc,
552 std::string* err_desc);
Steve Anton75737c02017-11-06 10:37:17 -0800553
Steve Anton75737c02017-11-06 10:37:17 -0800554 cricket::IceConfig ParseIceConfig(
555 const PeerConnectionInterface::RTCConfiguration& config) const;
556
Steve Anton75737c02017-11-06 10:37:17 -0800557 // Implements DataChannelProviderInterface.
558 bool SendData(const cricket::SendDataParams& params,
559 const rtc::CopyOnWriteBuffer& payload,
560 cricket::SendDataResult* result) override;
561 bool ConnectDataChannel(DataChannel* webrtc_data_channel) override;
562 void DisconnectDataChannel(DataChannel* webrtc_data_channel) override;
563 void AddSctpDataStream(int sid) override;
564 void RemoveSctpDataStream(int sid) override;
565 bool ReadyToSendData() const override;
566
567 cricket::DataChannelType data_channel_type() const;
568
Steve Anton75737c02017-11-06 10:37:17 -0800569 // Called when an RTCCertificate is generated or retrieved by
570 // WebRTCSessionDescriptionFactory. Should happen before setLocalDescription.
571 void OnCertificateReady(
572 const rtc::scoped_refptr<rtc::RTCCertificate>& certificate);
573 void OnDtlsSrtpSetupFailure(cricket::BaseChannel*, bool rtcp);
574
575 cricket::TransportController* transport_controller() const {
576 return transport_controller_.get();
577 }
578
579 // Return all managed, non-null channels.
580 std::vector<cricket::BaseChannel*> Channels() const;
581
582 // Non-const versions of local_description()/remote_description(), for use
583 // internally.
584 SessionDescriptionInterface* mutable_local_description() {
585 return pending_local_description_ ? pending_local_description_.get()
586 : current_local_description_.get();
587 }
588 SessionDescriptionInterface* mutable_remote_description() {
589 return pending_remote_description_ ? pending_remote_description_.get()
590 : current_remote_description_.get();
591 }
592
593 // Updates the error state, signaling if necessary.
594 void SetError(Error error, const std::string& error_desc);
595
596 bool UpdateSessionState(Action action,
597 cricket::ContentSource source,
598 std::string* err_desc);
599 Action GetAction(const std::string& type);
600 // Push the media parts of the local or remote session description
601 // down to all of the channels.
602 bool PushdownMediaDescription(cricket::ContentAction action,
603 cricket::ContentSource source,
604 std::string* error_desc);
605 bool PushdownSctpParameters_n(cricket::ContentSource source);
606
607 bool PushdownTransportDescription(cricket::ContentSource source,
608 cricket::ContentAction action,
609 std::string* error_desc);
610
611 // Helper methods to push local and remote transport descriptions.
612 bool PushdownLocalTransportDescription(
613 const cricket::SessionDescription* sdesc,
614 cricket::ContentAction action,
615 std::string* error_desc);
616 bool PushdownRemoteTransportDescription(
617 const cricket::SessionDescription* sdesc,
618 cricket::ContentAction action,
619 std::string* error_desc);
620
621 // Returns true and the TransportInfo of the given |content_name|
622 // from |description|. Returns false if it's not available.
623 static bool GetTransportDescription(
624 const cricket::SessionDescription* description,
625 const std::string& content_name,
626 cricket::TransportDescription* info);
627
628 // Returns the name of the transport channel when BUNDLE is enabled, or
629 // nullptr if the channel is not part of any bundle.
630 const std::string* GetBundleTransportName(
631 const cricket::ContentInfo* content,
632 const cricket::ContentGroup* bundle);
633
634 // Cause all the BaseChannels in the bundle group to have the same
635 // transport channel.
636 bool EnableBundle(const cricket::ContentGroup& bundle);
637
638 // Enables media channels to allow sending of media.
639 void EnableChannels();
640 // Returns the media index for a local ice candidate given the content name.
641 // Returns false if the local session description does not have a media
642 // content called |content_name|.
643 bool GetLocalCandidateMediaIndex(const std::string& content_name,
644 int* sdp_mline_index);
645 // Uses all remote candidates in |remote_desc| in this session.
646 bool UseCandidatesInSessionDescription(
647 const SessionDescriptionInterface* remote_desc);
648 // Uses |candidate| in this session.
649 bool UseCandidate(const IceCandidateInterface* candidate);
650 // Deletes the corresponding channel of contents that don't exist in |desc|.
651 // |desc| can be null. This means that all channels are deleted.
652 void RemoveUnusedChannels(const cricket::SessionDescription* desc);
653
654 // Allocates media channels based on the |desc|. If |desc| doesn't have
655 // the BUNDLE option, this method will disable BUNDLE in PortAllocator.
656 // This method will also delete any existing media channels before creating.
657 bool CreateChannels(const cricket::SessionDescription* desc);
658
659 // Helper methods to create media channels.
660 bool CreateVoiceChannel(const cricket::ContentInfo* content,
661 const std::string* bundle_transport);
662 bool CreateVideoChannel(const cricket::ContentInfo* content,
663 const std::string* bundle_transport);
664 bool CreateDataChannel(const cricket::ContentInfo* content,
665 const std::string* bundle_transport);
666
667 std::unique_ptr<SessionStats> GetSessionStats_n(
668 const ChannelNamePairs& channel_name_pairs);
669
670 bool CreateSctpTransport_n(const std::string& content_name,
671 const std::string& transport_name);
672 // For bundling.
673 void ChangeSctpTransport_n(const std::string& transport_name);
674 void DestroySctpTransport_n();
675 // SctpTransport signal handlers. Needed to marshal signals from the network
676 // to signaling thread.
677 void OnSctpTransportReadyToSendData_n();
678 // This may be called with "false" if the direction of the m= section causes
679 // us to tear down the SCTP connection.
680 void OnSctpTransportReadyToSendData_s(bool ready);
681 void OnSctpTransportDataReceived_n(const cricket::ReceiveDataParams& params,
682 const rtc::CopyOnWriteBuffer& payload);
683 // Beyond just firing the signal to the signaling thread, listens to SCTP
684 // CONTROL messages on unused SIDs and processes them as OPEN messages.
685 void OnSctpTransportDataReceived_s(const cricket::ReceiveDataParams& params,
686 const rtc::CopyOnWriteBuffer& payload);
687 void OnSctpStreamClosedRemotely_n(int sid);
688
689 bool ValidateBundleSettings(const cricket::SessionDescription* desc);
690 bool HasRtcpMuxEnabled(const cricket::ContentInfo* content);
691 // Below methods are helper methods which verifies SDP.
692 bool ValidateSessionDescription(const SessionDescriptionInterface* sdesc,
693 cricket::ContentSource source,
694 std::string* err_desc);
695
696 // Check if a call to SetLocalDescription is acceptable with |action|.
697 bool ExpectSetLocalDescription(Action action);
698 // Check if a call to SetRemoteDescription is acceptable with |action|.
699 bool ExpectSetRemoteDescription(Action action);
700 // Verifies a=setup attribute as per RFC 5763.
701 bool ValidateDtlsSetupAttribute(const cricket::SessionDescription* desc,
702 Action action);
703
704 // Returns true if we are ready to push down the remote candidate.
705 // |remote_desc| is the new remote description, or NULL if the current remote
706 // description should be used. Output |valid| is true if the candidate media
707 // index is valid.
708 bool ReadyToUseRemoteCandidate(const IceCandidateInterface* candidate,
709 const SessionDescriptionInterface* remote_desc,
710 bool* valid);
711
712 // Returns true if SRTP (either using DTLS-SRTP or SDES) is required by
713 // this session.
714 bool SrtpRequired() const;
715
716 // TransportController signal handlers.
717 void OnTransportControllerConnectionState(cricket::IceConnectionState state);
718 void OnTransportControllerGatheringState(cricket::IceGatheringState state);
719 void OnTransportControllerCandidatesGathered(
720 const std::string& transport_name,
721 const std::vector<cricket::Candidate>& candidates);
722 void OnTransportControllerCandidatesRemoved(
723 const std::vector<cricket::Candidate>& candidates);
724 void OnTransportControllerDtlsHandshakeError(rtc::SSLHandshakeError error);
725
726 std::string GetSessionErrorMsg();
727
728 // Invoked when TransportController connection completion is signaled.
729 // Reports stats for all transports in use.
730 void ReportTransportStats();
731
732 // Gather the usage of IPv4/IPv6 as best connection.
733 void ReportBestConnectionState(const cricket::TransportStats& stats);
734
735 void ReportNegotiatedCiphers(const cricket::TransportStats& stats);
736
737 void OnSentPacket_w(const rtc::SentPacket& sent_packet);
738
739 const std::string GetTransportName(const std::string& content_name);
740
741 void DestroyRtcpTransport_n(const std::string& transport_name);
742 void RemoveAndDestroyVideoChannel(cricket::VideoChannel* video_channel);
743 void DestroyVideoChannel(cricket::VideoChannel* video_channel);
744 void RemoveAndDestroyVoiceChannel(cricket::VoiceChannel* voice_channel);
745 void DestroyVoiceChannel(cricket::VoiceChannel* voice_channel);
746 void DestroyDataChannel();
747
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000748 // Storing the factory as a scoped reference pointer ensures that the memory
749 // in the PeerConnectionFactoryImpl remains available as long as the
750 // PeerConnection is running. It is passed to PeerConnection as a raw pointer.
751 // However, since the reference counting is done in the
deadbeefab9b2d12015-10-14 11:33:11 -0700752 // PeerConnectionFactoryInterface all instances created using the raw pointer
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000753 // will refer to the same reference count.
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000754 rtc::scoped_refptr<PeerConnectionFactory> factory_;
Steve Antonba818672017-11-06 10:21:57 -0800755 PeerConnectionObserver* observer_ = nullptr;
756 UMAObserver* uma_observer_ = nullptr;
terelius33860252017-05-12 23:37:18 -0700757
758 // The EventLog needs to outlive |call_| (and any other object that uses it).
759 std::unique_ptr<RtcEventLog> event_log_;
760
Steve Antonba818672017-11-06 10:21:57 -0800761 SignalingState signaling_state_ = kStable;
762 IceConnectionState ice_connection_state_ = kIceConnectionNew;
763 IceGatheringState ice_gathering_state_ = kIceGatheringNew;
deadbeef46c73892016-11-16 19:42:04 -0800764 PeerConnectionInterface::RTCConfiguration configuration_;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000765
kwibergd1fe2812016-04-27 06:47:29 -0700766 std::unique_ptr<cricket::PortAllocator> port_allocator_;
deadbeefab9b2d12015-10-14 11:33:11 -0700767
zhihuang8f65cdf2016-05-06 18:40:30 -0700768 // One PeerConnection has only one RTCP CNAME.
769 // https://tools.ietf.org/html/draft-ietf-rtcweb-rtp-usage-26#section-4.9
770 std::string rtcp_cname_;
771
deadbeefab9b2d12015-10-14 11:33:11 -0700772 // Streams added via AddStream.
773 rtc::scoped_refptr<StreamCollection> local_streams_;
774 // Streams created as a result of SetRemoteDescription.
775 rtc::scoped_refptr<StreamCollection> remote_streams_;
776
kwibergd1fe2812016-04-27 06:47:29 -0700777 std::vector<std::unique_ptr<MediaStreamObserver>> stream_observers_;
deadbeefeb459812015-12-15 19:24:43 -0800778
Steve Anton4171afb2017-11-20 10:20:22 -0800779 // These lists store sender info seen in local/remote descriptions.
780 std::vector<RtpSenderInfo> remote_audio_sender_infos_;
781 std::vector<RtpSenderInfo> remote_video_sender_infos_;
782 std::vector<RtpSenderInfo> local_audio_sender_infos_;
783 std::vector<RtpSenderInfo> local_video_sender_infos_;
deadbeefab9b2d12015-10-14 11:33:11 -0700784
785 SctpSidAllocator sid_allocator_;
786 // label -> DataChannel
787 std::map<std::string, rtc::scoped_refptr<DataChannel>> rtp_data_channels_;
788 std::vector<rtc::scoped_refptr<DataChannel>> sctp_data_channels_;
deadbeefbd292462015-12-14 18:15:29 -0800789 std::vector<rtc::scoped_refptr<DataChannel>> sctp_data_channels_to_free_;
deadbeefab9b2d12015-10-14 11:33:11 -0700790
deadbeefbda7e0b2015-12-08 17:13:40 -0800791 bool remote_peer_supports_msid_ = false;
deadbeef70ab1a12015-09-28 16:53:55 -0700792
terelius33860252017-05-12 23:37:18 -0700793 std::unique_ptr<Call> call_;
terelius33860252017-05-12 23:37:18 -0700794 std::unique_ptr<StatsCollector> stats_; // A pointer is passed to senders_
795 rtc::scoped_refptr<RTCStatsCollector> stats_collector_;
796
deadbeefa601f5c2016-06-06 14:27:39 -0700797 std::vector<
Steve Anton4171afb2017-11-20 10:20:22 -0800798 rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>>
799 transceivers_;
Steve Anton75737c02017-11-06 10:37:17 -0800800
801 Error error_ = ERROR_NONE;
802 std::string error_desc_;
803
804 std::string session_id_;
805 rtc::Optional<bool> initial_offerer_;
806
807 std::unique_ptr<cricket::TransportController> transport_controller_;
808 std::unique_ptr<cricket::SctpTransportInternalFactory> sctp_factory_;
Steve Anton75737c02017-11-06 10:37:17 -0800809 // |rtp_data_channel_| is used if in RTP data channel mode, |sctp_transport_|
810 // when using SCTP.
811 cricket::RtpDataChannel* rtp_data_channel_ = nullptr;
812
813 std::unique_ptr<cricket::SctpTransportInternal> sctp_transport_;
814 // |sctp_transport_name_| keeps track of what DTLS transport the SCTP
815 // transport is using (which can change due to bundling).
816 rtc::Optional<std::string> sctp_transport_name_;
817 // |sctp_content_name_| is the content name (MID) in SDP.
818 rtc::Optional<std::string> sctp_content_name_;
819 // Value cached on signaling thread. Only updated when SctpReadyToSendData
820 // fires on the signaling thread.
821 bool sctp_ready_to_send_data_ = false;
822 // Same as signals provided by SctpTransport, but these are guaranteed to
823 // fire on the signaling thread, whereas SctpTransport fires on the networking
824 // thread.
825 // |sctp_invoker_| is used so that any signals queued on the signaling thread
826 // from the network thread are immediately discarded if the SctpTransport is
827 // destroyed (due to m= section being rejected).
828 // TODO(deadbeef): Use a proxy object to ensure that method calls/signals
829 // are marshalled to the right thread. Could almost use proxy.h for this,
830 // but it doesn't have a mechanism for marshalling sigslot::signals
831 std::unique_ptr<rtc::AsyncInvoker> sctp_invoker_;
832 sigslot::signal1<bool> SignalSctpReadyToSendData;
833 sigslot::signal2<const cricket::ReceiveDataParams&,
834 const rtc::CopyOnWriteBuffer&>
835 SignalSctpDataReceived;
836 sigslot::signal1<int> SignalSctpStreamClosedRemotely;
837
838 std::unique_ptr<SessionDescriptionInterface> current_local_description_;
839 std::unique_ptr<SessionDescriptionInterface> pending_local_description_;
840 std::unique_ptr<SessionDescriptionInterface> current_remote_description_;
841 std::unique_ptr<SessionDescriptionInterface> pending_remote_description_;
842 bool dtls_enabled_ = false;
843 // Specifies which kind of data channel is allowed. This is controlled
844 // by the chrome command-line flag and constraints:
845 // 1. If chrome command-line switch 'enable-sctp-data-channels' is enabled,
846 // constraint kEnableDtlsSrtp is true, and constaint kEnableRtpDataChannels is
847 // not set or false, SCTP is allowed (DCT_SCTP);
848 // 2. If constraint kEnableRtpDataChannels is true, RTP is allowed (DCT_RTP);
849 // 3. If both 1&2 are false, data channel is not allowed (DCT_NONE).
850 cricket::DataChannelType data_channel_type_ = cricket::DCT_NONE;
851 // List of content names for which the remote side triggered an ICE restart.
852 std::set<std::string> pending_ice_restarts_;
853
854 std::unique_ptr<WebRtcSessionDescriptionFactory> webrtc_session_desc_factory_;
855
856 // Member variables for caching global options.
857 cricket::AudioOptions audio_options_;
858 cricket::VideoOptions video_options_;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000859};
860
861} // namespace webrtc
862
Mirko Bonadei92ea95e2017-09-15 06:47:31 +0200863#endif // PC_PEERCONNECTION_H_