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" |
34 #include "talk/app/webrtc/peerconnectionfactory.h" | 35 #include "talk/app/webrtc/peerconnectionfactory.h" |
35 #include "talk/app/webrtc/peerconnectioninterface.h" | 36 #include "talk/app/webrtc/peerconnectioninterface.h" |
36 #include "talk/app/webrtc/rtpreceiverinterface.h" | 37 #include "talk/app/webrtc/rtpreceiverinterface.h" |
37 #include "talk/app/webrtc/rtpsenderinterface.h" | 38 #include "talk/app/webrtc/rtpsenderinterface.h" |
38 #include "talk/app/webrtc/statscollector.h" | 39 #include "talk/app/webrtc/statscollector.h" |
39 #include "talk/app/webrtc/streamcollection.h" | 40 #include "talk/app/webrtc/streamcollection.h" |
40 #include "talk/app/webrtc/webrtcsession.h" | 41 #include "talk/app/webrtc/webrtcsession.h" |
41 #include "webrtc/base/scoped_ptr.h" | 42 #include "webrtc/base/scoped_ptr.h" |
42 | 43 |
43 namespace webrtc { | 44 namespace webrtc { |
44 | 45 |
45 class RemoteMediaStreamFactory; | |
46 | |
47 typedef std::vector<PortAllocatorFactoryInterface::StunConfiguration> | 46 typedef std::vector<PortAllocatorFactoryInterface::StunConfiguration> |
48 StunConfigurations; | 47 StunConfigurations; |
49 typedef std::vector<PortAllocatorFactoryInterface::TurnConfiguration> | 48 typedef std::vector<PortAllocatorFactoryInterface::TurnConfiguration> |
50 TurnConfigurations; | 49 TurnConfigurations; |
51 | 50 |
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 | |
65 // Parses the URLs for each server in |servers| to build |stun_config| and | 51 // Parses the URLs for each server in |servers| to build |stun_config| and |
66 // |turn_config|. | 52 // |turn_config|. |
67 bool ParseIceServers(const PeerConnectionInterface::IceServers& servers, | 53 bool ParseIceServers(const PeerConnectionInterface::IceServers& servers, |
68 StunConfigurations* stun_config, | 54 StunConfigurations* stun_config, |
69 TurnConfigurations* turn_config); | 55 TurnConfigurations* turn_config); |
70 | 56 |
71 // PeerConnection implements the PeerConnectionInterface interface. | 57 // PeerConnection implements the PeerConnectionInterface interface. |
72 // It uses WebRtcSession to implement the PeerConnection functionality. | 58 // It uses MediaStreamSignaling and WebRtcSession to implement |
| 59 // the PeerConnection functionality. |
73 class PeerConnection : public PeerConnectionInterface, | 60 class PeerConnection : public PeerConnectionInterface, |
| 61 public MediaStreamSignalingObserver, |
74 public IceObserver, | 62 public IceObserver, |
75 public rtc::MessageHandler, | 63 public rtc::MessageHandler, |
76 public sigslot::has_slots<> { | 64 public sigslot::has_slots<> { |
77 public: | 65 public: |
78 explicit PeerConnection(PeerConnectionFactory* factory); | 66 explicit PeerConnection(PeerConnectionFactory* factory); |
79 | 67 |
80 bool Initialize( | 68 bool Initialize( |
81 const PeerConnectionInterface::RTCConfiguration& configuration, | 69 const PeerConnectionInterface::RTCConfiguration& configuration, |
82 const MediaConstraintsInterface* constraints, | 70 const MediaConstraintsInterface* constraints, |
83 PortAllocatorFactoryInterface* allocator_factory, | 71 PortAllocatorFactoryInterface* allocator_factory, |
84 rtc::scoped_ptr<DtlsIdentityStoreInterface> dtls_identity_store, | 72 rtc::scoped_ptr<DtlsIdentityStoreInterface> dtls_identity_store, |
85 PeerConnectionObserver* observer); | 73 PeerConnectionObserver* observer); |
86 rtc::scoped_refptr<StreamCollectionInterface> local_streams() override; | 74 rtc::scoped_refptr<StreamCollectionInterface> local_streams() override; |
87 rtc::scoped_refptr<StreamCollectionInterface> remote_streams() override; | 75 rtc::scoped_refptr<StreamCollectionInterface> remote_streams() override; |
88 bool AddStream(MediaStreamInterface* local_stream) override; | 76 bool AddStream(MediaStreamInterface* local_stream) override; |
89 void RemoveStream(MediaStreamInterface* local_stream) override; | 77 void RemoveStream(MediaStreamInterface* local_stream) override; |
90 | 78 |
91 virtual WebRtcSession* session() { return session_.get(); } | |
92 | |
93 rtc::scoped_refptr<DtmfSenderInterface> CreateDtmfSender( | 79 rtc::scoped_refptr<DtmfSenderInterface> CreateDtmfSender( |
94 AudioTrackInterface* track) override; | 80 AudioTrackInterface* track) override; |
95 | 81 |
96 std::vector<rtc::scoped_refptr<RtpSenderInterface>> GetSenders() | 82 std::vector<rtc::scoped_refptr<RtpSenderInterface>> GetSenders() |
97 const override; | 83 const override; |
98 std::vector<rtc::scoped_refptr<RtpReceiverInterface>> GetReceivers() | 84 std::vector<rtc::scoped_refptr<RtpReceiverInterface>> GetReceivers() |
99 const override; | 85 const override; |
100 | 86 |
101 rtc::scoped_refptr<DataChannelInterface> CreateDataChannel( | 87 rtc::scoped_refptr<DataChannelInterface> CreateDataChannel( |
102 const std::string& label, | 88 const std::string& label, |
(...skipping 24 matching lines...) Expand all Loading... |
127 void SetRemoteDescription(SetSessionDescriptionObserver* observer, | 113 void SetRemoteDescription(SetSessionDescriptionObserver* observer, |
128 SessionDescriptionInterface* desc) override; | 114 SessionDescriptionInterface* desc) override; |
129 bool SetConfiguration( | 115 bool SetConfiguration( |
130 const PeerConnectionInterface::RTCConfiguration& config) override; | 116 const PeerConnectionInterface::RTCConfiguration& config) override; |
131 bool AddIceCandidate(const IceCandidateInterface* candidate) override; | 117 bool AddIceCandidate(const IceCandidateInterface* candidate) override; |
132 | 118 |
133 void RegisterUMAObserver(UMAObserver* observer) override; | 119 void RegisterUMAObserver(UMAObserver* observer) override; |
134 | 120 |
135 void Close() override; | 121 void Close() override; |
136 | 122 |
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 | |
143 protected: | 123 protected: |
144 ~PeerConnection() override; | 124 ~PeerConnection() override; |
145 | 125 |
146 private: | 126 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 | |
179 // Implements MessageHandler. | 127 // Implements MessageHandler. |
180 void OnMessage(rtc::Message* msg) override; | 128 void OnMessage(rtc::Message* msg) override; |
181 | 129 |
182 void CreateAudioReceiver(MediaStreamInterface* stream, | 130 // Implements MediaStreamSignalingObserver. |
183 AudioTrackInterface* audio_track, | 131 void OnAddRemoteStream(MediaStreamInterface* stream) override; |
184 uint32_t ssrc); | 132 void OnRemoveRemoteStream(MediaStreamInterface* stream) override; |
185 void CreateVideoReceiver(MediaStreamInterface* stream, | 133 void OnAddDataChannel(DataChannelInterface* data_channel) override; |
186 VideoTrackInterface* video_track, | 134 void OnAddRemoteAudioTrack(MediaStreamInterface* stream, |
187 uint32_t ssrc); | 135 AudioTrackInterface* audio_track, |
188 void DestroyAudioReceiver(MediaStreamInterface* stream, | 136 uint32_t ssrc) override; |
189 AudioTrackInterface* audio_track); | 137 void OnAddRemoteVideoTrack(MediaStreamInterface* stream, |
190 void DestroyVideoReceiver(MediaStreamInterface* stream, | 138 VideoTrackInterface* video_track, |
191 VideoTrackInterface* video_track); | 139 uint32_t ssrc) override; |
192 void CreateAudioSender(MediaStreamInterface* stream, | 140 void OnRemoveRemoteAudioTrack(MediaStreamInterface* stream, |
193 AudioTrackInterface* audio_track, | 141 AudioTrackInterface* audio_track) override; |
194 uint32_t ssrc); | 142 void OnRemoveRemoteVideoTrack(MediaStreamInterface* stream, |
195 void CreateVideoSender(MediaStreamInterface* stream, | 143 VideoTrackInterface* video_track) override; |
196 VideoTrackInterface* video_track, | 144 void OnAddLocalAudioTrack(MediaStreamInterface* stream, |
197 uint32_t ssrc); | 145 AudioTrackInterface* audio_track, |
198 void DestroyAudioSender(MediaStreamInterface* stream, | 146 uint32_t ssrc) override; |
199 AudioTrackInterface* audio_track, | 147 void OnAddLocalVideoTrack(MediaStreamInterface* stream, |
200 uint32_t ssrc); | 148 VideoTrackInterface* video_track, |
201 void DestroyVideoSender(MediaStreamInterface* stream, | 149 uint32_t ssrc) override; |
202 VideoTrackInterface* video_track); | 150 void OnRemoveLocalAudioTrack(MediaStreamInterface* stream, |
| 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; |
203 | 156 |
204 // Implements IceObserver | 157 // Implements IceObserver |
205 void OnIceConnectionChange(IceConnectionState new_state) override; | 158 void OnIceConnectionChange(IceConnectionState new_state) override; |
206 void OnIceGatheringChange(IceGatheringState new_state) override; | 159 void OnIceGatheringChange(IceGatheringState new_state) override; |
207 void OnIceCandidate(const IceCandidateInterface* candidate) override; | 160 void OnIceCandidate(const IceCandidateInterface* candidate) override; |
208 void OnIceComplete() override; | 161 void OnIceComplete() override; |
209 void OnIceConnectionReceivingChange(bool receiving) override; | 162 void OnIceConnectionReceivingChange(bool receiving) override; |
210 | 163 |
211 // Signals from WebRtcSession. | 164 // Signals from WebRtcSession. |
212 void OnSessionStateChange(cricket::BaseSession* session, | 165 void OnSessionStateChange(cricket::BaseSession* session, |
213 cricket::BaseSession::State state); | 166 cricket::BaseSession::State state); |
214 void ChangeSignalingState(SignalingState signaling_state); | 167 void ChangeSignalingState(SignalingState signaling_state); |
215 | 168 |
216 rtc::Thread* signaling_thread() const { | 169 rtc::Thread* signaling_thread() const { |
217 return factory_->signaling_thread(); | 170 return factory_->signaling_thread(); |
218 } | 171 } |
219 | 172 |
220 void PostSetSessionDescriptionFailure(SetSessionDescriptionObserver* observer, | 173 void PostSetSessionDescriptionFailure(SetSessionDescriptionObserver* observer, |
221 const std::string& error); | 174 const std::string& error); |
222 void PostCreateSessionDescriptionFailure( | |
223 CreateSessionDescriptionObserver* observer, | |
224 const std::string& error); | |
225 | 175 |
226 bool IsClosed() const { | 176 bool IsClosed() const { |
227 return signaling_state_ == PeerConnectionInterface::kClosed; | 177 return signaling_state_ == PeerConnectionInterface::kClosed; |
228 } | 178 } |
229 | 179 |
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 | |
334 std::vector<rtc::scoped_refptr<RtpSenderInterface>>::iterator | 180 std::vector<rtc::scoped_refptr<RtpSenderInterface>>::iterator |
335 FindSenderForTrack(MediaStreamTrackInterface* track); | 181 FindSenderForTrack(MediaStreamTrackInterface* track); |
336 std::vector<rtc::scoped_refptr<RtpReceiverInterface>>::iterator | 182 std::vector<rtc::scoped_refptr<RtpReceiverInterface>>::iterator |
337 FindReceiverForTrack(MediaStreamTrackInterface* track); | 183 FindReceiverForTrack(MediaStreamTrackInterface* track); |
338 | 184 |
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 | |
349 // Storing the factory as a scoped reference pointer ensures that the memory | 185 // Storing the factory as a scoped reference pointer ensures that the memory |
350 // in the PeerConnectionFactoryImpl remains available as long as the | 186 // in the PeerConnectionFactoryImpl remains available as long as the |
351 // PeerConnection is running. It is passed to PeerConnection as a raw pointer. | 187 // PeerConnection is running. It is passed to PeerConnection as a raw pointer. |
352 // However, since the reference counting is done in the | 188 // However, since the reference counting is done in the |
353 // PeerConnectionFactoryInterface all instances created using the raw pointer | 189 // PeerConnectionFactoryInteface all instances created using the raw pointer |
354 // will refer to the same reference count. | 190 // will refer to the same reference count. |
355 rtc::scoped_refptr<PeerConnectionFactory> factory_; | 191 rtc::scoped_refptr<PeerConnectionFactory> factory_; |
356 PeerConnectionObserver* observer_; | 192 PeerConnectionObserver* observer_; |
357 UMAObserver* uma_observer_; | 193 UMAObserver* uma_observer_; |
358 SignalingState signaling_state_; | 194 SignalingState signaling_state_; |
359 // TODO(bemasc): Remove ice_state_. | 195 // TODO(bemasc): Remove ice_state_. |
360 IceState ice_state_; | 196 IceState ice_state_; |
361 IceConnectionState ice_connection_state_; | 197 IceConnectionState ice_connection_state_; |
362 IceGatheringState ice_gathering_state_; | 198 IceGatheringState ice_gathering_state_; |
363 | 199 |
364 rtc::scoped_ptr<cricket::PortAllocator> port_allocator_; | 200 rtc::scoped_ptr<cricket::PortAllocator> port_allocator_; |
365 | 201 rtc::scoped_ptr<WebRtcSession> session_; |
366 // Streams added via AddStream. | 202 rtc::scoped_ptr<MediaStreamSignaling> mediastream_signaling_; |
367 rtc::scoped_refptr<StreamCollection> local_streams_; | 203 rtc::scoped_ptr<StatsCollector> stats_; |
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_; | |
384 | 204 |
385 std::vector<rtc::scoped_refptr<RtpSenderInterface>> senders_; | 205 std::vector<rtc::scoped_refptr<RtpSenderInterface>> senders_; |
386 std::vector<rtc::scoped_refptr<RtpReceiverInterface>> receivers_; | 206 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_; | |
394 }; | 207 }; |
395 | 208 |
396 } // namespace webrtc | 209 } // namespace webrtc |
397 | 210 |
398 #endif // TALK_APP_WEBRTC_PEERCONNECTION_H_ | 211 #endif // TALK_APP_WEBRTC_PEERCONNECTION_H_ |
OLD | NEW |