OLD | NEW |
1 /* | 1 /* |
2 * libjingle | 2 * libjingle |
3 * Copyright 2012 Google Inc. | 3 * Copyright 2012 Google Inc. |
4 * | 4 * |
5 * Redistribution and use in source and binary forms, with or without | 5 * Redistribution and use in source and binary forms, with or without |
6 * modification, are permitted provided that the following conditions are met: | 6 * modification, are permitted provided that the following conditions are met: |
7 * | 7 * |
8 * 1. Redistributions of source code must retain the above copyright notice, | 8 * 1. Redistributions of source code must retain the above copyright notice, |
9 * this list of conditions and the following disclaimer. | 9 * this list of conditions and the following disclaimer. |
10 * 2. Redistributions in binary form must reproduce the above copyright notice, | 10 * 2. Redistributions in binary form must reproduce the above copyright notice, |
(...skipping 13 matching lines...) Expand all Loading... |
24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF | 24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | 25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
26 */ | 26 */ |
27 | 27 |
28 #ifndef TALK_APP_WEBRTC_PEERCONNECTION_H_ | 28 #ifndef TALK_APP_WEBRTC_PEERCONNECTION_H_ |
29 #define TALK_APP_WEBRTC_PEERCONNECTION_H_ | 29 #define TALK_APP_WEBRTC_PEERCONNECTION_H_ |
30 | 30 |
31 #include <string> | 31 #include <string> |
32 | 32 |
33 #include "talk/app/webrtc/dtlsidentitystore.h" | 33 #include "talk/app/webrtc/dtlsidentitystore.h" |
34 #include "talk/app/webrtc/mediastreamsignaling.h" | |
35 #include "talk/app/webrtc/peerconnectionfactory.h" | 34 #include "talk/app/webrtc/peerconnectionfactory.h" |
36 #include "talk/app/webrtc/peerconnectioninterface.h" | 35 #include "talk/app/webrtc/peerconnectioninterface.h" |
37 #include "talk/app/webrtc/rtpreceiverinterface.h" | 36 #include "talk/app/webrtc/rtpreceiverinterface.h" |
38 #include "talk/app/webrtc/rtpsenderinterface.h" | 37 #include "talk/app/webrtc/rtpsenderinterface.h" |
39 #include "talk/app/webrtc/statscollector.h" | 38 #include "talk/app/webrtc/statscollector.h" |
40 #include "talk/app/webrtc/streamcollection.h" | 39 #include "talk/app/webrtc/streamcollection.h" |
41 #include "talk/app/webrtc/webrtcsession.h" | 40 #include "talk/app/webrtc/webrtcsession.h" |
42 #include "webrtc/base/scoped_ptr.h" | 41 #include "webrtc/base/scoped_ptr.h" |
43 | 42 |
44 namespace webrtc { | 43 namespace webrtc { |
45 | 44 |
| 45 class RemoteMediaStreamFactory; |
| 46 |
46 typedef std::vector<PortAllocatorFactoryInterface::StunConfiguration> | 47 typedef std::vector<PortAllocatorFactoryInterface::StunConfiguration> |
47 StunConfigurations; | 48 StunConfigurations; |
48 typedef std::vector<PortAllocatorFactoryInterface::TurnConfiguration> | 49 typedef std::vector<PortAllocatorFactoryInterface::TurnConfiguration> |
49 TurnConfigurations; | 50 TurnConfigurations; |
50 | 51 |
| 52 // Populates |session_options| from |rtc_options|, and returns true if options |
| 53 // are valid. |
| 54 // Send streams should already be added to |session_options| before this method |
| 55 // is called, as this affects the values of recv_audio and recv_video. |
| 56 bool ConvertRtcOptionsForOffer( |
| 57 const PeerConnectionInterface::RTCOfferAnswerOptions& rtc_options, |
| 58 cricket::MediaSessionOptions* session_options); |
| 59 |
| 60 // Populates |session_options| from |constraints|, and returns true if all |
| 61 // mandatory constraints are satisfied. |
| 62 bool ParseConstraintsForAnswer(const MediaConstraintsInterface* constraints, |
| 63 cricket::MediaSessionOptions* session_options); |
| 64 |
51 // Parses the URLs for each server in |servers| to build |stun_config| and | 65 // Parses the URLs for each server in |servers| to build |stun_config| and |
52 // |turn_config|. | 66 // |turn_config|. |
53 bool ParseIceServers(const PeerConnectionInterface::IceServers& servers, | 67 bool ParseIceServers(const PeerConnectionInterface::IceServers& servers, |
54 StunConfigurations* stun_config, | 68 StunConfigurations* stun_config, |
55 TurnConfigurations* turn_config); | 69 TurnConfigurations* turn_config); |
56 | 70 |
57 // PeerConnection implements the PeerConnectionInterface interface. | 71 // PeerConnection implements the PeerConnectionInterface interface. |
58 // It uses MediaStreamSignaling and WebRtcSession to implement | 72 // It uses WebRtcSession to implement the PeerConnection functionality. |
59 // the PeerConnection functionality. | |
60 class PeerConnection : public PeerConnectionInterface, | 73 class PeerConnection : public PeerConnectionInterface, |
61 public MediaStreamSignalingObserver, | |
62 public IceObserver, | 74 public IceObserver, |
63 public rtc::MessageHandler, | 75 public rtc::MessageHandler, |
64 public sigslot::has_slots<> { | 76 public sigslot::has_slots<> { |
65 public: | 77 public: |
66 explicit PeerConnection(PeerConnectionFactory* factory); | 78 explicit PeerConnection(PeerConnectionFactory* factory); |
67 | 79 |
68 bool Initialize( | 80 bool Initialize( |
69 const PeerConnectionInterface::RTCConfiguration& configuration, | 81 const PeerConnectionInterface::RTCConfiguration& configuration, |
70 const MediaConstraintsInterface* constraints, | 82 const MediaConstraintsInterface* constraints, |
71 PortAllocatorFactoryInterface* allocator_factory, | 83 PortAllocatorFactoryInterface* allocator_factory, |
72 rtc::scoped_ptr<DtlsIdentityStoreInterface> dtls_identity_store, | 84 rtc::scoped_ptr<DtlsIdentityStoreInterface> dtls_identity_store, |
73 PeerConnectionObserver* observer); | 85 PeerConnectionObserver* observer); |
74 rtc::scoped_refptr<StreamCollectionInterface> local_streams() override; | 86 rtc::scoped_refptr<StreamCollectionInterface> local_streams() override; |
75 rtc::scoped_refptr<StreamCollectionInterface> remote_streams() override; | 87 rtc::scoped_refptr<StreamCollectionInterface> remote_streams() override; |
76 bool AddStream(MediaStreamInterface* local_stream) override; | 88 bool AddStream(MediaStreamInterface* local_stream) override; |
77 void RemoveStream(MediaStreamInterface* local_stream) override; | 89 void RemoveStream(MediaStreamInterface* local_stream) override; |
78 | 90 |
| 91 virtual WebRtcSession* session() { return session_.get(); } |
| 92 |
79 rtc::scoped_refptr<DtmfSenderInterface> CreateDtmfSender( | 93 rtc::scoped_refptr<DtmfSenderInterface> CreateDtmfSender( |
80 AudioTrackInterface* track) override; | 94 AudioTrackInterface* track) override; |
81 | 95 |
82 std::vector<rtc::scoped_refptr<RtpSenderInterface>> GetSenders() | 96 std::vector<rtc::scoped_refptr<RtpSenderInterface>> GetSenders() |
83 const override; | 97 const override; |
84 std::vector<rtc::scoped_refptr<RtpReceiverInterface>> GetReceivers() | 98 std::vector<rtc::scoped_refptr<RtpReceiverInterface>> GetReceivers() |
85 const override; | 99 const override; |
86 | 100 |
87 rtc::scoped_refptr<DataChannelInterface> CreateDataChannel( | 101 rtc::scoped_refptr<DataChannelInterface> CreateDataChannel( |
88 const std::string& label, | 102 const std::string& label, |
(...skipping 24 matching lines...) Expand all Loading... |
113 void SetRemoteDescription(SetSessionDescriptionObserver* observer, | 127 void SetRemoteDescription(SetSessionDescriptionObserver* observer, |
114 SessionDescriptionInterface* desc) override; | 128 SessionDescriptionInterface* desc) override; |
115 bool SetConfiguration( | 129 bool SetConfiguration( |
116 const PeerConnectionInterface::RTCConfiguration& config) override; | 130 const PeerConnectionInterface::RTCConfiguration& config) override; |
117 bool AddIceCandidate(const IceCandidateInterface* candidate) override; | 131 bool AddIceCandidate(const IceCandidateInterface* candidate) override; |
118 | 132 |
119 void RegisterUMAObserver(UMAObserver* observer) override; | 133 void RegisterUMAObserver(UMAObserver* observer) override; |
120 | 134 |
121 void Close() override; | 135 void Close() override; |
122 | 136 |
| 137 // Virtual for unit tests. |
| 138 virtual const std::vector<rtc::scoped_refptr<DataChannel>>& |
| 139 sctp_data_channels() const { |
| 140 return sctp_data_channels_; |
| 141 }; |
| 142 |
123 protected: | 143 protected: |
124 ~PeerConnection() override; | 144 ~PeerConnection() override; |
125 | 145 |
126 private: | 146 private: |
| 147 struct TrackInfo { |
| 148 TrackInfo() : ssrc(0) {} |
| 149 TrackInfo(const std::string& stream_label, |
| 150 const std::string track_id, |
| 151 uint32_t ssrc) |
| 152 : stream_label(stream_label), track_id(track_id), ssrc(ssrc) {} |
| 153 std::string stream_label; |
| 154 std::string track_id; |
| 155 uint32_t ssrc; |
| 156 }; |
| 157 typedef std::vector<TrackInfo> TrackInfos; |
| 158 |
| 159 struct RemotePeerInfo { |
| 160 RemotePeerInfo() |
| 161 : msid_supported(false), |
| 162 default_audio_track_needed(false), |
| 163 default_video_track_needed(false) {} |
| 164 // True if it has been discovered that the remote peer support MSID. |
| 165 bool msid_supported; |
| 166 // The remote peer indicates in the session description that audio will be |
| 167 // sent but no MSID is given. |
| 168 bool default_audio_track_needed; |
| 169 // The remote peer indicates in the session description that video will be |
| 170 // sent but no MSID is given. |
| 171 bool default_video_track_needed; |
| 172 |
| 173 bool IsDefaultMediaStreamNeeded() { |
| 174 return !msid_supported && |
| 175 (default_audio_track_needed || default_video_track_needed); |
| 176 } |
| 177 }; |
| 178 |
127 // Implements MessageHandler. | 179 // Implements MessageHandler. |
128 void OnMessage(rtc::Message* msg) override; | 180 void OnMessage(rtc::Message* msg) override; |
129 | 181 |
130 // Implements MediaStreamSignalingObserver. | 182 void CreateAudioReceiver(MediaStreamInterface* stream, |
131 void OnAddRemoteStream(MediaStreamInterface* stream) override; | 183 AudioTrackInterface* audio_track, |
132 void OnRemoveRemoteStream(MediaStreamInterface* stream) override; | 184 uint32_t ssrc); |
133 void OnAddDataChannel(DataChannelInterface* data_channel) override; | 185 void CreateVideoReceiver(MediaStreamInterface* stream, |
134 void OnAddRemoteAudioTrack(MediaStreamInterface* stream, | 186 VideoTrackInterface* video_track, |
135 AudioTrackInterface* audio_track, | 187 uint32_t ssrc); |
136 uint32_t ssrc) override; | 188 void DestroyAudioReceiver(MediaStreamInterface* stream, |
137 void OnAddRemoteVideoTrack(MediaStreamInterface* stream, | 189 AudioTrackInterface* audio_track); |
138 VideoTrackInterface* video_track, | 190 void DestroyVideoReceiver(MediaStreamInterface* stream, |
139 uint32_t ssrc) override; | 191 VideoTrackInterface* video_track); |
140 void OnRemoveRemoteAudioTrack(MediaStreamInterface* stream, | 192 void CreateAudioSender(MediaStreamInterface* stream, |
141 AudioTrackInterface* audio_track) override; | 193 AudioTrackInterface* audio_track, |
142 void OnRemoveRemoteVideoTrack(MediaStreamInterface* stream, | 194 uint32_t ssrc); |
143 VideoTrackInterface* video_track) override; | 195 void CreateVideoSender(MediaStreamInterface* stream, |
144 void OnAddLocalAudioTrack(MediaStreamInterface* stream, | 196 VideoTrackInterface* video_track, |
145 AudioTrackInterface* audio_track, | 197 uint32_t ssrc); |
146 uint32_t ssrc) override; | 198 void DestroyAudioSender(MediaStreamInterface* stream, |
147 void OnAddLocalVideoTrack(MediaStreamInterface* stream, | 199 AudioTrackInterface* audio_track, |
148 VideoTrackInterface* video_track, | 200 uint32_t ssrc); |
149 uint32_t ssrc) override; | 201 void DestroyVideoSender(MediaStreamInterface* stream, |
150 void OnRemoveLocalAudioTrack(MediaStreamInterface* stream, | 202 VideoTrackInterface* video_track); |
151 AudioTrackInterface* audio_track, | |
152 uint32_t ssrc) override; | |
153 void OnRemoveLocalVideoTrack(MediaStreamInterface* stream, | |
154 VideoTrackInterface* video_track) override; | |
155 void OnRemoveLocalStream(MediaStreamInterface* stream) override; | |
156 | 203 |
157 // Implements IceObserver | 204 // Implements IceObserver |
158 void OnIceConnectionChange(IceConnectionState new_state) override; | 205 void OnIceConnectionChange(IceConnectionState new_state) override; |
159 void OnIceGatheringChange(IceGatheringState new_state) override; | 206 void OnIceGatheringChange(IceGatheringState new_state) override; |
160 void OnIceCandidate(const IceCandidateInterface* candidate) override; | 207 void OnIceCandidate(const IceCandidateInterface* candidate) override; |
161 void OnIceComplete() override; | 208 void OnIceComplete() override; |
162 void OnIceConnectionReceivingChange(bool receiving) override; | 209 void OnIceConnectionReceivingChange(bool receiving) override; |
163 | 210 |
164 // Signals from WebRtcSession. | 211 // Signals from WebRtcSession. |
165 void OnSessionStateChange(cricket::BaseSession* session, | 212 void OnSessionStateChange(cricket::BaseSession* session, |
166 cricket::BaseSession::State state); | 213 cricket::BaseSession::State state); |
167 void ChangeSignalingState(SignalingState signaling_state); | 214 void ChangeSignalingState(SignalingState signaling_state); |
168 | 215 |
169 rtc::Thread* signaling_thread() const { | 216 rtc::Thread* signaling_thread() const { |
170 return factory_->signaling_thread(); | 217 return factory_->signaling_thread(); |
171 } | 218 } |
172 | 219 |
173 void PostSetSessionDescriptionFailure(SetSessionDescriptionObserver* observer, | 220 void PostSetSessionDescriptionFailure(SetSessionDescriptionObserver* observer, |
174 const std::string& error); | 221 const std::string& error); |
| 222 void PostCreateSessionDescriptionFailure( |
| 223 CreateSessionDescriptionObserver* observer, |
| 224 const std::string& error); |
175 | 225 |
176 bool IsClosed() const { | 226 bool IsClosed() const { |
177 return signaling_state_ == PeerConnectionInterface::kClosed; | 227 return signaling_state_ == PeerConnectionInterface::kClosed; |
178 } | 228 } |
179 | 229 |
| 230 // Returns a MediaSessionOptions struct with options decided by |options|, |
| 231 // the local MediaStreams and DataChannels. |
| 232 virtual bool GetOptionsForOffer( |
| 233 const PeerConnectionInterface::RTCOfferAnswerOptions& rtc_options, |
| 234 cricket::MediaSessionOptions* session_options); |
| 235 |
| 236 // Returns a MediaSessionOptions struct with options decided by |
| 237 // |constraints|, the local MediaStreams and DataChannels. |
| 238 virtual bool GetOptionsForAnswer( |
| 239 const MediaConstraintsInterface* constraints, |
| 240 cricket::MediaSessionOptions* session_options); |
| 241 |
| 242 // Makes sure a MediaStream Track is created for each StreamParam in |
| 243 // |streams|. |media_type| is the type of the |streams| and can be either |
| 244 // audio or video. |
| 245 // If a new MediaStream is created it is added to |new_streams|. |
| 246 void UpdateRemoteStreamsList( |
| 247 const std::vector<cricket::StreamParams>& streams, |
| 248 cricket::MediaType media_type, |
| 249 StreamCollection* new_streams); |
| 250 |
| 251 // Triggered when a remote track has been seen for the first time in a remote |
| 252 // session description. It creates a remote MediaStreamTrackInterface |
| 253 // implementation and triggers CreateAudioReceiver or CreateVideoReceiver. |
| 254 void OnRemoteTrackSeen(const std::string& stream_label, |
| 255 const std::string& track_id, |
| 256 uint32_t ssrc, |
| 257 cricket::MediaType media_type); |
| 258 |
| 259 // Triggered when a remote track has been removed from a remote session |
| 260 // description. It removes the remote track with id |track_id| from a remote |
| 261 // MediaStream and triggers DestroyAudioReceiver or DestroyVideoReceiver. |
| 262 void OnRemoteTrackRemoved(const std::string& stream_label, |
| 263 const std::string& track_id, |
| 264 cricket::MediaType media_type); |
| 265 |
| 266 // Finds remote MediaStreams without any tracks and removes them from |
| 267 // |remote_streams_| and notifies the observer that the MediaStreams no longer |
| 268 // exist. |
| 269 void UpdateEndedRemoteMediaStreams(); |
| 270 |
| 271 void MaybeCreateDefaultStream(); |
| 272 |
| 273 // Set the MediaStreamTrackInterface::TrackState to |kEnded| on all remote |
| 274 // tracks of type |media_type|. |
| 275 void EndRemoteTracks(cricket::MediaType media_type); |
| 276 |
| 277 // Loops through the vector of |streams| and finds added and removed |
| 278 // StreamParams since last time this method was called. |
| 279 // For each new or removed StreamParam, OnLocalTrackSeen or |
| 280 // OnLocalTrackRemoved is invoked. |
| 281 void UpdateLocalTracks(const std::vector<cricket::StreamParams>& streams, |
| 282 cricket::MediaType media_type); |
| 283 |
| 284 // Triggered when a local track has been seen for the first time in a local |
| 285 // session description. |
| 286 // This method triggers CreateAudioSender or CreateVideoSender if the rtp |
| 287 // streams in the local SessionDescription can be mapped to a MediaStreamTrack |
| 288 // in a MediaStream in |local_streams_| |
| 289 void OnLocalTrackSeen(const std::string& stream_label, |
| 290 const std::string& track_id, |
| 291 uint32_t ssrc, |
| 292 cricket::MediaType media_type); |
| 293 |
| 294 // Triggered when a local track has been removed from a local session |
| 295 // description. |
| 296 // This method triggers DestroyAudioSender or DestroyVideoSender if a stream |
| 297 // has been removed from the local SessionDescription and the stream can be |
| 298 // mapped to a MediaStreamTrack in a MediaStream in |local_streams_|. |
| 299 void OnLocalTrackRemoved(const std::string& stream_label, |
| 300 const std::string& track_id, |
| 301 uint32_t ssrc, |
| 302 cricket::MediaType media_type); |
| 303 |
| 304 void UpdateLocalRtpDataChannels(const cricket::StreamParamsVec& streams); |
| 305 void UpdateRemoteRtpDataChannels(const cricket::StreamParamsVec& streams); |
| 306 void UpdateClosingRtpDataChannels( |
| 307 const std::vector<std::string>& active_channels, |
| 308 bool is_local_update); |
| 309 void CreateRemoteRtpDataChannel(const std::string& label, |
| 310 uint32_t remote_ssrc); |
| 311 |
| 312 // Creates channel and adds it to the collection of DataChannels that will |
| 313 // be offered in a SessionDescription. |
| 314 rtc::scoped_refptr<DataChannel> InternalCreateDataChannel( |
| 315 const std::string& label, |
| 316 const InternalDataChannelInit* config); |
| 317 |
| 318 // Checks if any data channel has been added. |
| 319 bool HasDataChannels() const; |
| 320 |
| 321 void AllocateSctpSids(rtc::SSLRole role); |
| 322 void OnSctpDataChannelClosed(DataChannel* channel); |
| 323 |
| 324 // Notifications from WebRtcSession relating to BaseChannels. |
| 325 void OnVoiceChannelDestroyed(); |
| 326 void OnVideoChannelDestroyed(); |
| 327 void OnDataChannelCreated(); |
| 328 void OnDataChannelDestroyed(); |
| 329 // Called when the cricket::DataChannel receives a message indicating that a |
| 330 // webrtc::DataChannel should be opened. |
| 331 void OnDataChannelOpenMessage(const std::string& label, |
| 332 const InternalDataChannelInit& config); |
| 333 |
180 std::vector<rtc::scoped_refptr<RtpSenderInterface>>::iterator | 334 std::vector<rtc::scoped_refptr<RtpSenderInterface>>::iterator |
181 FindSenderForTrack(MediaStreamTrackInterface* track); | 335 FindSenderForTrack(MediaStreamTrackInterface* track); |
182 std::vector<rtc::scoped_refptr<RtpReceiverInterface>>::iterator | 336 std::vector<rtc::scoped_refptr<RtpReceiverInterface>>::iterator |
183 FindReceiverForTrack(MediaStreamTrackInterface* track); | 337 FindReceiverForTrack(MediaStreamTrackInterface* track); |
184 | 338 |
| 339 TrackInfos* GetRemoteTracks(cricket::MediaType media_type); |
| 340 TrackInfos* GetLocalTracks(cricket::MediaType media_type); |
| 341 const TrackInfo* FindTrackInfo(const TrackInfos& infos, |
| 342 const std::string& stream_label, |
| 343 const std::string track_id) const; |
| 344 |
| 345 // Returns the specified SCTP DataChannel in sctp_data_channels_, |
| 346 // or nullptr if not found. |
| 347 DataChannel* FindDataChannelBySid(int sid) const; |
| 348 |
185 // Storing the factory as a scoped reference pointer ensures that the memory | 349 // Storing the factory as a scoped reference pointer ensures that the memory |
186 // in the PeerConnectionFactoryImpl remains available as long as the | 350 // in the PeerConnectionFactoryImpl remains available as long as the |
187 // PeerConnection is running. It is passed to PeerConnection as a raw pointer. | 351 // PeerConnection is running. It is passed to PeerConnection as a raw pointer. |
188 // However, since the reference counting is done in the | 352 // However, since the reference counting is done in the |
189 // PeerConnectionFactoryInteface all instances created using the raw pointer | 353 // PeerConnectionFactoryInterface all instances created using the raw pointer |
190 // will refer to the same reference count. | 354 // will refer to the same reference count. |
191 rtc::scoped_refptr<PeerConnectionFactory> factory_; | 355 rtc::scoped_refptr<PeerConnectionFactory> factory_; |
192 PeerConnectionObserver* observer_; | 356 PeerConnectionObserver* observer_; |
193 UMAObserver* uma_observer_; | 357 UMAObserver* uma_observer_; |
194 SignalingState signaling_state_; | 358 SignalingState signaling_state_; |
195 // TODO(bemasc): Remove ice_state_. | 359 // TODO(bemasc): Remove ice_state_. |
196 IceState ice_state_; | 360 IceState ice_state_; |
197 IceConnectionState ice_connection_state_; | 361 IceConnectionState ice_connection_state_; |
198 IceGatheringState ice_gathering_state_; | 362 IceGatheringState ice_gathering_state_; |
199 | 363 |
200 rtc::scoped_ptr<cricket::PortAllocator> port_allocator_; | 364 rtc::scoped_ptr<cricket::PortAllocator> port_allocator_; |
201 rtc::scoped_ptr<WebRtcSession> session_; | 365 |
202 rtc::scoped_ptr<MediaStreamSignaling> mediastream_signaling_; | 366 // Streams added via AddStream. |
203 rtc::scoped_ptr<StatsCollector> stats_; | 367 rtc::scoped_refptr<StreamCollection> local_streams_; |
| 368 // Streams created as a result of SetRemoteDescription. |
| 369 rtc::scoped_refptr<StreamCollection> remote_streams_; |
| 370 |
| 371 // These lists store track info seen in local/remote descriptions. |
| 372 TrackInfos remote_audio_tracks_; |
| 373 TrackInfos remote_video_tracks_; |
| 374 TrackInfos local_audio_tracks_; |
| 375 TrackInfos local_video_tracks_; |
| 376 |
| 377 SctpSidAllocator sid_allocator_; |
| 378 // label -> DataChannel |
| 379 std::map<std::string, rtc::scoped_refptr<DataChannel>> rtp_data_channels_; |
| 380 std::vector<rtc::scoped_refptr<DataChannel>> sctp_data_channels_; |
| 381 |
| 382 RemotePeerInfo remote_info_; |
| 383 rtc::scoped_ptr<RemoteMediaStreamFactory> remote_stream_factory_; |
204 | 384 |
205 std::vector<rtc::scoped_refptr<RtpSenderInterface>> senders_; | 385 std::vector<rtc::scoped_refptr<RtpSenderInterface>> senders_; |
206 std::vector<rtc::scoped_refptr<RtpReceiverInterface>> receivers_; | 386 std::vector<rtc::scoped_refptr<RtpReceiverInterface>> receivers_; |
| 387 |
| 388 // The session_ scoped_ptr is declared at the bottom of PeerConnection |
| 389 // because its destruction fires signals (such as VoiceChannelDestroyed) |
| 390 // which will trigger some final actions in PeerConnection... |
| 391 rtc::scoped_ptr<WebRtcSession> session_; |
| 392 // ... But stats_ depends on session_ so it should be destroyed even earlier. |
| 393 rtc::scoped_ptr<StatsCollector> stats_; |
207 }; | 394 }; |
208 | 395 |
209 } // namespace webrtc | 396 } // namespace webrtc |
210 | 397 |
211 #endif // TALK_APP_WEBRTC_PEERCONNECTION_H_ | 398 #endif // TALK_APP_WEBRTC_PEERCONNECTION_H_ |
OLD | NEW |