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 ssrc) | |
152 : stream_label(stream_label), track_id(track_id), ssrc(ssrc) {} | |
153 std::string stream_label; | |
154 std::string track_id; | |
155 uint32 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 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 ssrc); |
136 uint32 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 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 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 ssrc); |
146 uint32 ssrc) override; | 198 void DestroyAudioSender(MediaStreamInterface* stream, |
147 void OnAddLocalVideoTrack(MediaStreamInterface* stream, | 199 AudioTrackInterface* audio_track, |
148 VideoTrackInterface* video_track, | 200 uint32 ssrc); |
149 uint32 ssrc) override; | 201 void DestroyVideoSender(MediaStreamInterface* stream, |
150 void OnRemoveLocalAudioTrack(MediaStreamInterface* stream, | 202 VideoTrackInterface* video_track); |
151 AudioTrackInterface* audio_track, | |
152 uint32 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 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 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 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, uint32 remote_ssrc); | |
310 | |
311 // Creates channel and adds it to the collection of DataChannels that will | |
312 // be offered in a SessionDescription. | |
313 rtc::scoped_refptr<DataChannel> InternalCreateDataChannel( | |
314 const std::string& label, | |
315 const InternalDataChannelInit* config); | |
316 | |
317 // Checks if any data channel has been added. | |
318 bool HasDataChannels() const; | |
319 | |
320 void AllocateSctpSids(rtc::SSLRole role); | |
321 void OnSctpDataChannelClosed(DataChannel* channel); | |
322 | |
323 // Notifications from WebRtcSession relating to BaseChannels. | |
324 void OnVoiceChannelDestroyed(); | |
325 void OnVideoChannelDestroyed(); | |
326 void OnDataChannelCreated(); | |
327 void OnDataChannelDestroyed(); | |
328 // Called when the cricket::DataChannel receives a message indicating that a | |
329 // webrtc::DataChannel should be opened. | |
330 void OnDataChannelOpenMessage(const std::string& label, | |
331 const InternalDataChannelInit& config); | |
332 | |
180 std::vector<rtc::scoped_refptr<RtpSenderInterface>>::iterator | 333 std::vector<rtc::scoped_refptr<RtpSenderInterface>>::iterator |
181 FindSenderForTrack(MediaStreamTrackInterface* track); | 334 FindSenderForTrack(MediaStreamTrackInterface* track); |
182 std::vector<rtc::scoped_refptr<RtpReceiverInterface>>::iterator | 335 std::vector<rtc::scoped_refptr<RtpReceiverInterface>>::iterator |
183 FindReceiverForTrack(MediaStreamTrackInterface* track); | 336 FindReceiverForTrack(MediaStreamTrackInterface* track); |
184 | 337 |
338 TrackInfos* GetRemoteTracks(cricket::MediaType media_type); | |
339 TrackInfos* GetLocalTracks(cricket::MediaType media_type); | |
340 const TrackInfo* FindTrackInfo(const TrackInfos& infos, | |
341 const std::string& stream_label, | |
342 const std::string track_id) const; | |
343 | |
344 // Returns the specified SCTP DataChannel in sctp_data_channels_, | |
345 // or nullptr if not found. | |
346 DataChannel* FindDataChannelBySid(int sid) const; | |
347 | |
185 // Storing the factory as a scoped reference pointer ensures that the memory | 348 // Storing the factory as a scoped reference pointer ensures that the memory |
186 // in the PeerConnectionFactoryImpl remains available as long as the | 349 // in the PeerConnectionFactoryImpl remains available as long as the |
187 // PeerConnection is running. It is passed to PeerConnection as a raw pointer. | 350 // PeerConnection is running. It is passed to PeerConnection as a raw pointer. |
188 // However, since the reference counting is done in the | 351 // However, since the reference counting is done in the |
189 // PeerConnectionFactoryInteface all instances created using the raw pointer | 352 // PeerConnectionFactoryInterface all instances created using the raw pointer |
190 // will refer to the same reference count. | 353 // will refer to the same reference count. |
191 rtc::scoped_refptr<PeerConnectionFactory> factory_; | 354 rtc::scoped_refptr<PeerConnectionFactory> factory_; |
192 PeerConnectionObserver* observer_; | 355 PeerConnectionObserver* observer_; |
193 UMAObserver* uma_observer_; | 356 UMAObserver* uma_observer_; |
194 SignalingState signaling_state_; | 357 SignalingState signaling_state_; |
195 // TODO(bemasc): Remove ice_state_. | 358 // TODO(bemasc): Remove ice_state_. |
196 IceState ice_state_; | 359 IceState ice_state_; |
197 IceConnectionState ice_connection_state_; | 360 IceConnectionState ice_connection_state_; |
198 IceGatheringState ice_gathering_state_; | 361 IceGatheringState ice_gathering_state_; |
199 | 362 |
200 rtc::scoped_ptr<cricket::PortAllocator> port_allocator_; | 363 rtc::scoped_ptr<cricket::PortAllocator> port_allocator_; |
201 rtc::scoped_ptr<WebRtcSession> session_; | 364 |
202 rtc::scoped_ptr<MediaStreamSignaling> mediastream_signaling_; | 365 // Streams added via AddStream. |
203 rtc::scoped_ptr<StatsCollector> stats_; | 366 rtc::scoped_refptr<StreamCollection> local_streams_; |
367 // Streams created as a result of SetRemoteDescription. | |
368 rtc::scoped_refptr<StreamCollection> remote_streams_; | |
369 | |
370 // These lists store track info seen in local/remote descriptions. | |
371 TrackInfos remote_audio_tracks_; | |
372 TrackInfos remote_video_tracks_; | |
373 TrackInfos local_audio_tracks_; | |
374 TrackInfos local_video_tracks_; | |
375 | |
376 SctpSidAllocator sid_allocator_; | |
377 // label -> DataChannel | |
378 std::map<std::string, rtc::scoped_refptr<DataChannel>> rtp_data_channels_; | |
379 std::vector<rtc::scoped_refptr<DataChannel>> sctp_data_channels_; | |
380 | |
381 RemotePeerInfo remote_info_; | |
382 rtc::scoped_ptr<RemoteMediaStreamFactory> remote_stream_factory_; | |
204 | 383 |
205 std::vector<rtc::scoped_refptr<RtpSenderInterface>> senders_; | 384 std::vector<rtc::scoped_refptr<RtpSenderInterface>> senders_; |
206 std::vector<rtc::scoped_refptr<RtpReceiverInterface>> receivers_; | 385 std::vector<rtc::scoped_refptr<RtpReceiverInterface>> receivers_; |
386 | |
387 // The session_ scoped_ptr is declared at the bottom of PeerConnection | |
388 // because its destruction fires signals (such as VoiceChannelDestroyed) | |
389 // which will trigger some final actions in PeerConnection. | |
390 rtc::scoped_ptr<WebRtcSession> session_; | |
391 rtc::scoped_ptr<StatsCollector> stats_; | |
pthatcher1
2015/10/09 21:12:26
Now session_ isn't at the bottom :). Can you comm
| |
207 }; | 392 }; |
208 | 393 |
209 } // namespace webrtc | 394 } // namespace webrtc |
210 | 395 |
211 #endif // TALK_APP_WEBRTC_PEERCONNECTION_H_ | 396 #endif // TALK_APP_WEBRTC_PEERCONNECTION_H_ |
OLD | NEW |