henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1 | /* |
kjellander | b24317b | 2016-02-10 07:54:43 -0800 | [diff] [blame] | 2 | * Copyright 2012 The WebRTC project authors. All Rights Reserved. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 3 | * |
kjellander | b24317b | 2016-02-10 07:54:43 -0800 | [diff] [blame] | 4 | * 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.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 9 | */ |
| 10 | |
| 11 | // This file contains mock implementations of observers used in PeerConnection. |
Steve Anton | 94286cb | 2017-09-26 16:20:19 -0700 | [diff] [blame] | 12 | // TODO(steveanton): These aren't really mocks and should be renamed. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 13 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 14 | #ifndef PC_TEST_MOCKPEERCONNECTIONOBSERVERS_H_ |
| 15 | #define PC_TEST_MOCKPEERCONNECTIONOBSERVERS_H_ |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 16 | |
Steve Anton | ef65ef1 | 2018-01-10 17:15:20 -0800 | [diff] [blame] | 17 | #include <map> |
kwiberg | d1fe281 | 2016-04-27 06:47:29 -0700 | [diff] [blame] | 18 | #include <memory> |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 19 | #include <string> |
Steve Anton | 36b29d1 | 2017-10-30 09:57:42 -0700 | [diff] [blame] | 20 | #include <utility> |
| 21 | #include <vector> |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 22 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 23 | #include "api/datachannelinterface.h" |
Steve Anton | f1c6db1 | 2017-10-13 11:13:35 -0700 | [diff] [blame] | 24 | #include "api/jsepicecandidate.h" |
Steve Anton | 94286cb | 2017-09-26 16:20:19 -0700 | [diff] [blame] | 25 | #include "pc/streamcollection.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 26 | #include "rtc_base/checks.h" |
Steve Anton | f1c6db1 | 2017-10-13 11:13:35 -0700 | [diff] [blame] | 27 | #include "rtc_base/ptr_util.h" |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 28 | |
| 29 | namespace webrtc { |
| 30 | |
Steve Anton | 94286cb | 2017-09-26 16:20:19 -0700 | [diff] [blame] | 31 | class MockPeerConnectionObserver : public PeerConnectionObserver { |
| 32 | public: |
Henrik Boström | 933d8b0 | 2017-10-10 10:05:16 -0700 | [diff] [blame] | 33 | struct AddTrackEvent { |
| 34 | explicit AddTrackEvent( |
Steve Anton | ef65ef1 | 2018-01-10 17:15:20 -0800 | [diff] [blame] | 35 | rtc::scoped_refptr<RtpReceiverInterface> event_receiver, |
| 36 | std::vector<rtc::scoped_refptr<MediaStreamInterface>> event_streams) |
| 37 | : receiver(std::move(event_receiver)), |
| 38 | streams(std::move(event_streams)) { |
| 39 | for (auto stream : streams) { |
| 40 | std::vector<rtc::scoped_refptr<MediaStreamTrackInterface>> tracks; |
| 41 | for (auto audio_track : stream->GetAudioTracks()) { |
| 42 | tracks.push_back(audio_track); |
| 43 | } |
| 44 | for (auto video_track : stream->GetVideoTracks()) { |
| 45 | tracks.push_back(video_track); |
| 46 | } |
| 47 | snapshotted_stream_tracks[stream] = tracks; |
| 48 | } |
| 49 | } |
Henrik Boström | 933d8b0 | 2017-10-10 10:05:16 -0700 | [diff] [blame] | 50 | |
| 51 | rtc::scoped_refptr<RtpReceiverInterface> receiver; |
| 52 | std::vector<rtc::scoped_refptr<MediaStreamInterface>> streams; |
Steve Anton | ef65ef1 | 2018-01-10 17:15:20 -0800 | [diff] [blame] | 53 | // This map records the tracks present in each stream at the time the |
| 54 | // OnAddTrack callback was issued. |
| 55 | std::map<rtc::scoped_refptr<MediaStreamInterface>, |
| 56 | std::vector<rtc::scoped_refptr<MediaStreamTrackInterface>>> |
| 57 | snapshotted_stream_tracks; |
Henrik Boström | 933d8b0 | 2017-10-10 10:05:16 -0700 | [diff] [blame] | 58 | }; |
| 59 | |
Steve Anton | 94286cb | 2017-09-26 16:20:19 -0700 | [diff] [blame] | 60 | MockPeerConnectionObserver() : remote_streams_(StreamCollection::Create()) {} |
| 61 | virtual ~MockPeerConnectionObserver() {} |
| 62 | void SetPeerConnectionInterface(PeerConnectionInterface* pc) { |
| 63 | pc_ = pc; |
| 64 | if (pc) { |
| 65 | state_ = pc_->signaling_state(); |
| 66 | } |
| 67 | } |
| 68 | void OnSignalingChange( |
| 69 | PeerConnectionInterface::SignalingState new_state) override { |
| 70 | RTC_DCHECK(pc_->signaling_state() == new_state); |
| 71 | state_ = new_state; |
| 72 | } |
| 73 | |
| 74 | MediaStreamInterface* RemoteStream(const std::string& label) { |
| 75 | return remote_streams_->find(label); |
| 76 | } |
| 77 | StreamCollectionInterface* remote_streams() const { return remote_streams_; } |
| 78 | void OnAddStream(rtc::scoped_refptr<MediaStreamInterface> stream) override { |
| 79 | last_added_stream_ = stream; |
| 80 | remote_streams_->AddStream(stream); |
| 81 | } |
| 82 | void OnRemoveStream( |
| 83 | rtc::scoped_refptr<MediaStreamInterface> stream) override { |
| 84 | last_removed_stream_ = stream; |
| 85 | remote_streams_->RemoveStream(stream); |
| 86 | } |
| 87 | void OnRenegotiationNeeded() override { renegotiation_needed_ = true; } |
| 88 | void OnDataChannel( |
| 89 | rtc::scoped_refptr<DataChannelInterface> data_channel) override { |
| 90 | last_datachannel_ = data_channel; |
| 91 | } |
| 92 | |
| 93 | void OnIceConnectionChange( |
| 94 | PeerConnectionInterface::IceConnectionState new_state) override { |
| 95 | RTC_DCHECK(pc_->ice_connection_state() == new_state); |
Steve Anton | 6f25b09 | 2017-10-23 09:39:20 -0700 | [diff] [blame] | 96 | ice_connected_ = |
| 97 | (new_state == PeerConnectionInterface::kIceConnectionConnected); |
Steve Anton | 94286cb | 2017-09-26 16:20:19 -0700 | [diff] [blame] | 98 | callback_triggered_ = true; |
| 99 | } |
| 100 | void OnIceGatheringChange( |
| 101 | PeerConnectionInterface::IceGatheringState new_state) override { |
| 102 | RTC_DCHECK(pc_->ice_gathering_state() == new_state); |
Steve Anton | 6f25b09 | 2017-10-23 09:39:20 -0700 | [diff] [blame] | 103 | ice_gathering_complete_ = |
| 104 | new_state == PeerConnectionInterface::kIceGatheringComplete; |
Steve Anton | 94286cb | 2017-09-26 16:20:19 -0700 | [diff] [blame] | 105 | callback_triggered_ = true; |
| 106 | } |
Steve Anton | f1c6db1 | 2017-10-13 11:13:35 -0700 | [diff] [blame] | 107 | void OnIceCandidate(const IceCandidateInterface* candidate) override { |
Steve Anton | 94286cb | 2017-09-26 16:20:19 -0700 | [diff] [blame] | 108 | RTC_DCHECK(PeerConnectionInterface::kIceGatheringNew != |
| 109 | pc_->ice_gathering_state()); |
Steve Anton | f1c6db1 | 2017-10-13 11:13:35 -0700 | [diff] [blame] | 110 | candidates_.push_back(rtc::MakeUnique<JsepIceCandidate>( |
| 111 | candidate->sdp_mid(), candidate->sdp_mline_index(), |
| 112 | candidate->candidate())); |
Steve Anton | 94286cb | 2017-09-26 16:20:19 -0700 | [diff] [blame] | 113 | callback_triggered_ = true; |
| 114 | } |
| 115 | |
| 116 | void OnIceCandidatesRemoved( |
| 117 | const std::vector<cricket::Candidate>& candidates) override { |
Steve Anton | f1c6db1 | 2017-10-13 11:13:35 -0700 | [diff] [blame] | 118 | num_candidates_removed_++; |
Steve Anton | 94286cb | 2017-09-26 16:20:19 -0700 | [diff] [blame] | 119 | callback_triggered_ = true; |
| 120 | } |
| 121 | |
| 122 | void OnIceConnectionReceivingChange(bool receiving) override { |
| 123 | callback_triggered_ = true; |
| 124 | } |
| 125 | |
Henrik Boström | 933d8b0 | 2017-10-10 10:05:16 -0700 | [diff] [blame] | 126 | void OnAddTrack(rtc::scoped_refptr<RtpReceiverInterface> receiver, |
| 127 | const std::vector<rtc::scoped_refptr<MediaStreamInterface>>& |
| 128 | streams) override { |
Steve Anton | 94286cb | 2017-09-26 16:20:19 -0700 | [diff] [blame] | 129 | RTC_DCHECK(receiver); |
| 130 | num_added_tracks_++; |
| 131 | last_added_track_label_ = receiver->id(); |
Henrik Boström | 933d8b0 | 2017-10-10 10:05:16 -0700 | [diff] [blame] | 132 | add_track_events_.push_back(AddTrackEvent(receiver, streams)); |
| 133 | } |
| 134 | |
Steve Anton | 8b815cd | 2018-02-16 16:14:42 -0800 | [diff] [blame] | 135 | void OnTrack( |
| 136 | rtc::scoped_refptr<RtpTransceiverInterface> transceiver) override { |
| 137 | on_track_transceivers_.push_back(transceiver); |
| 138 | } |
| 139 | |
Henrik Boström | 933d8b0 | 2017-10-10 10:05:16 -0700 | [diff] [blame] | 140 | void OnRemoveTrack( |
| 141 | rtc::scoped_refptr<RtpReceiverInterface> receiver) override { |
| 142 | remove_track_events_.push_back(receiver); |
| 143 | } |
| 144 | |
| 145 | std::vector<rtc::scoped_refptr<RtpReceiverInterface>> GetAddTrackReceivers() { |
| 146 | std::vector<rtc::scoped_refptr<RtpReceiverInterface>> receivers; |
| 147 | for (const AddTrackEvent& event : add_track_events_) { |
| 148 | receivers.push_back(event.receiver); |
| 149 | } |
| 150 | return receivers; |
Steve Anton | 94286cb | 2017-09-26 16:20:19 -0700 | [diff] [blame] | 151 | } |
| 152 | |
Steve Anton | 36da6ff | 2018-02-16 16:04:20 -0800 | [diff] [blame] | 153 | int CountAddTrackEventsForStream(const std::string& stream_label) { |
| 154 | int found_tracks = 0; |
| 155 | for (const AddTrackEvent& event : add_track_events_) { |
| 156 | bool has_stream_label = false; |
| 157 | for (auto stream : event.streams) { |
| 158 | if (stream->label() == stream_label) { |
| 159 | has_stream_label = true; |
| 160 | break; |
| 161 | } |
| 162 | } |
| 163 | if (has_stream_label) { |
| 164 | ++found_tracks; |
| 165 | } |
| 166 | } |
| 167 | return found_tracks; |
| 168 | } |
| 169 | |
Steve Anton | 94286cb | 2017-09-26 16:20:19 -0700 | [diff] [blame] | 170 | // Returns the label of the last added stream. |
| 171 | // Empty string if no stream have been added. |
| 172 | std::string GetLastAddedStreamLabel() { |
| 173 | if (last_added_stream_.get()) |
| 174 | return last_added_stream_->label(); |
| 175 | return ""; |
| 176 | } |
| 177 | std::string GetLastRemovedStreamLabel() { |
| 178 | if (last_removed_stream_.get()) |
| 179 | return last_removed_stream_->label(); |
| 180 | return ""; |
| 181 | } |
| 182 | |
Steve Anton | f1c6db1 | 2017-10-13 11:13:35 -0700 | [diff] [blame] | 183 | IceCandidateInterface* last_candidate() { |
| 184 | if (candidates_.empty()) { |
| 185 | return nullptr; |
| 186 | } else { |
| 187 | return candidates_.back().get(); |
| 188 | } |
| 189 | } |
| 190 | |
| 191 | std::vector<IceCandidateInterface*> GetCandidatesByMline(int mline_index) { |
| 192 | std::vector<IceCandidateInterface*> candidates; |
| 193 | for (const auto& candidate : candidates_) { |
| 194 | if (candidate->sdp_mline_index() == mline_index) { |
| 195 | candidates.push_back(candidate.get()); |
| 196 | } |
| 197 | } |
| 198 | return candidates; |
| 199 | } |
| 200 | |
Steve Anton | f9381f0 | 2017-12-14 10:23:57 -0800 | [diff] [blame] | 201 | bool negotiation_needed() const { return renegotiation_needed_; } |
| 202 | void clear_negotiation_needed() { renegotiation_needed_ = false; } |
| 203 | |
Steve Anton | 94286cb | 2017-09-26 16:20:19 -0700 | [diff] [blame] | 204 | rtc::scoped_refptr<PeerConnectionInterface> pc_; |
| 205 | PeerConnectionInterface::SignalingState state_; |
Steve Anton | f1c6db1 | 2017-10-13 11:13:35 -0700 | [diff] [blame] | 206 | std::vector<std::unique_ptr<IceCandidateInterface>> candidates_; |
Steve Anton | 94286cb | 2017-09-26 16:20:19 -0700 | [diff] [blame] | 207 | rtc::scoped_refptr<DataChannelInterface> last_datachannel_; |
| 208 | rtc::scoped_refptr<StreamCollection> remote_streams_; |
| 209 | bool renegotiation_needed_ = false; |
Steve Anton | 6f25b09 | 2017-10-23 09:39:20 -0700 | [diff] [blame] | 210 | bool ice_gathering_complete_ = false; |
| 211 | bool ice_connected_ = false; |
Steve Anton | 94286cb | 2017-09-26 16:20:19 -0700 | [diff] [blame] | 212 | bool callback_triggered_ = false; |
| 213 | int num_added_tracks_ = 0; |
| 214 | std::string last_added_track_label_; |
Henrik Boström | 933d8b0 | 2017-10-10 10:05:16 -0700 | [diff] [blame] | 215 | std::vector<AddTrackEvent> add_track_events_; |
| 216 | std::vector<rtc::scoped_refptr<RtpReceiverInterface>> remove_track_events_; |
Steve Anton | 8b815cd | 2018-02-16 16:14:42 -0800 | [diff] [blame] | 217 | std::vector<rtc::scoped_refptr<RtpTransceiverInterface>> |
| 218 | on_track_transceivers_; |
Steve Anton | f1c6db1 | 2017-10-13 11:13:35 -0700 | [diff] [blame] | 219 | int num_candidates_removed_ = 0; |
Steve Anton | 94286cb | 2017-09-26 16:20:19 -0700 | [diff] [blame] | 220 | |
| 221 | private: |
| 222 | rtc::scoped_refptr<MediaStreamInterface> last_added_stream_; |
| 223 | rtc::scoped_refptr<MediaStreamInterface> last_removed_stream_; |
| 224 | }; |
| 225 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 226 | class MockCreateSessionDescriptionObserver |
| 227 | : public webrtc::CreateSessionDescriptionObserver { |
| 228 | public: |
| 229 | MockCreateSessionDescriptionObserver() |
| 230 | : called_(false), |
Steve Anton | 8d3444d | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 231 | error_("MockCreateSessionDescriptionObserver not called") {} |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 232 | virtual ~MockCreateSessionDescriptionObserver() {} |
| 233 | virtual void OnSuccess(SessionDescriptionInterface* desc) { |
| 234 | called_ = true; |
Steve Anton | 8d3444d | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 235 | error_ = ""; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 236 | desc_.reset(desc); |
| 237 | } |
| 238 | virtual void OnFailure(const std::string& error) { |
| 239 | called_ = true; |
Steve Anton | 8d3444d | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 240 | error_ = error; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 241 | } |
| 242 | bool called() const { return called_; } |
Steve Anton | 8d3444d | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 243 | bool result() const { return error_.empty(); } |
| 244 | const std::string& error() const { return error_; } |
deadbeef | 1dcb164 | 2017-03-29 21:08:16 -0700 | [diff] [blame] | 245 | std::unique_ptr<SessionDescriptionInterface> MoveDescription() { |
| 246 | return std::move(desc_); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 247 | } |
| 248 | |
| 249 | private: |
| 250 | bool called_; |
Steve Anton | 8d3444d | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 251 | std::string error_; |
kwiberg | d1fe281 | 2016-04-27 06:47:29 -0700 | [diff] [blame] | 252 | std::unique_ptr<SessionDescriptionInterface> desc_; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 253 | }; |
| 254 | |
| 255 | class MockSetSessionDescriptionObserver |
| 256 | : public webrtc::SetSessionDescriptionObserver { |
| 257 | public: |
| 258 | MockSetSessionDescriptionObserver() |
| 259 | : called_(false), |
Steve Anton | 8d3444d | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 260 | error_("MockSetSessionDescriptionObserver not called") {} |
Henrik Boström | 3163867 | 2017-11-23 17:48:32 +0100 | [diff] [blame] | 261 | ~MockSetSessionDescriptionObserver() override {} |
| 262 | void OnSuccess() override { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 263 | called_ = true; |
Steve Anton | 8d3444d | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 264 | error_ = ""; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 265 | } |
Henrik Boström | 3163867 | 2017-11-23 17:48:32 +0100 | [diff] [blame] | 266 | void OnFailure(const std::string& error) override { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 267 | called_ = true; |
Steve Anton | 8d3444d | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 268 | error_ = error; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 269 | } |
| 270 | bool called() const { return called_; } |
Steve Anton | 8d3444d | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 271 | bool result() const { return error_.empty(); } |
| 272 | const std::string& error() const { return error_; } |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 273 | |
| 274 | private: |
| 275 | bool called_; |
Steve Anton | 8d3444d | 2017-10-20 15:30:51 -0700 | [diff] [blame] | 276 | std::string error_; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 277 | }; |
| 278 | |
Henrik Boström | 3163867 | 2017-11-23 17:48:32 +0100 | [diff] [blame] | 279 | class MockSetRemoteDescriptionObserver |
| 280 | : public rtc::RefCountedObject<SetRemoteDescriptionObserverInterface> { |
| 281 | public: |
| 282 | bool called() const { return error_.has_value(); } |
| 283 | RTCError& error() { |
| 284 | RTC_DCHECK(error_.has_value()); |
| 285 | return *error_; |
| 286 | } |
| 287 | |
| 288 | // SetRemoteDescriptionObserverInterface implementation. |
| 289 | void OnSetRemoteDescriptionComplete(RTCError error) override { |
| 290 | error_ = std::move(error); |
| 291 | } |
| 292 | |
| 293 | private: |
| 294 | // Set on complete, on success this is set to an RTCError::OK() error. |
| 295 | rtc::Optional<RTCError> error_; |
| 296 | }; |
| 297 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 298 | class MockDataChannelObserver : public webrtc::DataChannelObserver { |
| 299 | public: |
| 300 | explicit MockDataChannelObserver(webrtc::DataChannelInterface* channel) |
Taylor Brandstetter | 9b5306c | 2016-08-18 11:40:37 -0700 | [diff] [blame] | 301 | : channel_(channel) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 302 | channel_->RegisterObserver(this); |
| 303 | state_ = channel_->state(); |
| 304 | } |
| 305 | virtual ~MockDataChannelObserver() { |
| 306 | channel_->UnregisterObserver(); |
| 307 | } |
| 308 | |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 309 | void OnBufferedAmountChange(uint64_t previous_amount) override {} |
bemasc | 0edd50c | 2015-07-01 13:34:33 -0700 | [diff] [blame] | 310 | |
| 311 | void OnStateChange() override { state_ = channel_->state(); } |
| 312 | void OnMessage(const DataBuffer& buffer) override { |
Taylor Brandstetter | 9b5306c | 2016-08-18 11:40:37 -0700 | [diff] [blame] | 313 | messages_.push_back( |
| 314 | std::string(buffer.data.data<char>(), buffer.data.size())); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 315 | } |
| 316 | |
| 317 | bool IsOpen() const { return state_ == DataChannelInterface::kOpen; } |
Taylor Brandstetter | 9b5306c | 2016-08-18 11:40:37 -0700 | [diff] [blame] | 318 | std::vector<std::string> messages() const { return messages_; } |
| 319 | std::string last_message() const { |
| 320 | return messages_.empty() ? std::string() : messages_.back(); |
| 321 | } |
| 322 | size_t received_message_count() const { return messages_.size(); } |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 323 | |
| 324 | private: |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 325 | rtc::scoped_refptr<webrtc::DataChannelInterface> channel_; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 326 | DataChannelInterface::DataState state_; |
Taylor Brandstetter | 9b5306c | 2016-08-18 11:40:37 -0700 | [diff] [blame] | 327 | std::vector<std::string> messages_; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 328 | }; |
| 329 | |
| 330 | class MockStatsObserver : public webrtc::StatsObserver { |
| 331 | public: |
tommi@webrtc.org | 209df9b | 2014-12-17 14:09:05 +0000 | [diff] [blame] | 332 | MockStatsObserver() : called_(false), stats_() {} |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 333 | virtual ~MockStatsObserver() {} |
tommi@webrtc.org | 209df9b | 2014-12-17 14:09:05 +0000 | [diff] [blame] | 334 | |
nisse | e8abe3e | 2017-01-18 05:00:34 -0800 | [diff] [blame] | 335 | virtual void OnComplete(const StatsReports& reports) { |
nisse | c8ee882 | 2017-01-18 07:20:55 -0800 | [diff] [blame] | 336 | RTC_CHECK(!called_); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 337 | called_ = true; |
pthatcher@webrtc.org | 7bea1ff | 2015-03-04 01:38:30 +0000 | [diff] [blame] | 338 | stats_.Clear(); |
nisse | e8abe3e | 2017-01-18 05:00:34 -0800 | [diff] [blame] | 339 | stats_.number_of_reports = reports.size(); |
| 340 | for (const auto* r : reports) { |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 341 | if (r->type() == StatsReport::kStatsReportTypeSsrc) { |
jbauch | be24c94 | 2015-06-22 15:06:43 -0700 | [diff] [blame] | 342 | stats_.timestamp = r->timestamp(); |
tommi@webrtc.org | 209df9b | 2014-12-17 14:09:05 +0000 | [diff] [blame] | 343 | GetIntValue(r, StatsReport::kStatsValueNameAudioOutputLevel, |
| 344 | &stats_.audio_output_level); |
| 345 | GetIntValue(r, StatsReport::kStatsValueNameAudioInputLevel, |
| 346 | &stats_.audio_input_level); |
| 347 | GetIntValue(r, StatsReport::kStatsValueNameBytesReceived, |
| 348 | &stats_.bytes_received); |
| 349 | GetIntValue(r, StatsReport::kStatsValueNameBytesSent, |
| 350 | &stats_.bytes_sent); |
Fredrik Solenberg | 73276ad | 2017-09-14 14:46:47 +0200 | [diff] [blame] | 351 | GetInt64Value(r, StatsReport::kStatsValueNameCaptureStartNtpTimeMs, |
| 352 | &stats_.capture_start_ntp_time); |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 353 | } else if (r->type() == StatsReport::kStatsReportTypeBwe) { |
jbauch | be24c94 | 2015-06-22 15:06:43 -0700 | [diff] [blame] | 354 | stats_.timestamp = r->timestamp(); |
tommi@webrtc.org | 209df9b | 2014-12-17 14:09:05 +0000 | [diff] [blame] | 355 | GetIntValue(r, StatsReport::kStatsValueNameAvailableReceiveBandwidth, |
| 356 | &stats_.available_receive_bandwidth); |
pthatcher@webrtc.org | 7bea1ff | 2015-03-04 01:38:30 +0000 | [diff] [blame] | 357 | } else if (r->type() == StatsReport::kStatsReportTypeComponent) { |
jbauch | be24c94 | 2015-06-22 15:06:43 -0700 | [diff] [blame] | 358 | stats_.timestamp = r->timestamp(); |
pthatcher@webrtc.org | 7bea1ff | 2015-03-04 01:38:30 +0000 | [diff] [blame] | 359 | GetStringValue(r, StatsReport::kStatsValueNameDtlsCipher, |
| 360 | &stats_.dtls_cipher); |
| 361 | GetStringValue(r, StatsReport::kStatsValueNameSrtpCipher, |
| 362 | &stats_.srtp_cipher); |
tommi@webrtc.org | 209df9b | 2014-12-17 14:09:05 +0000 | [diff] [blame] | 363 | } |
| 364 | } |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 365 | } |
| 366 | |
| 367 | bool called() const { return called_; } |
tommi@webrtc.org | 209df9b | 2014-12-17 14:09:05 +0000 | [diff] [blame] | 368 | size_t number_of_reports() const { return stats_.number_of_reports; } |
jbauch | be24c94 | 2015-06-22 15:06:43 -0700 | [diff] [blame] | 369 | double timestamp() const { return stats_.timestamp; } |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 370 | |
tommi@webrtc.org | 209df9b | 2014-12-17 14:09:05 +0000 | [diff] [blame] | 371 | int AudioOutputLevel() const { |
nisse | c8ee882 | 2017-01-18 07:20:55 -0800 | [diff] [blame] | 372 | RTC_CHECK(called_); |
tommi@webrtc.org | 209df9b | 2014-12-17 14:09:05 +0000 | [diff] [blame] | 373 | return stats_.audio_output_level; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 374 | } |
| 375 | |
tommi@webrtc.org | 209df9b | 2014-12-17 14:09:05 +0000 | [diff] [blame] | 376 | int AudioInputLevel() const { |
nisse | c8ee882 | 2017-01-18 07:20:55 -0800 | [diff] [blame] | 377 | RTC_CHECK(called_); |
tommi@webrtc.org | 209df9b | 2014-12-17 14:09:05 +0000 | [diff] [blame] | 378 | return stats_.audio_input_level; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 379 | } |
| 380 | |
tommi@webrtc.org | 209df9b | 2014-12-17 14:09:05 +0000 | [diff] [blame] | 381 | int BytesReceived() const { |
nisse | c8ee882 | 2017-01-18 07:20:55 -0800 | [diff] [blame] | 382 | RTC_CHECK(called_); |
tommi@webrtc.org | 209df9b | 2014-12-17 14:09:05 +0000 | [diff] [blame] | 383 | return stats_.bytes_received; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 384 | } |
| 385 | |
tommi@webrtc.org | 209df9b | 2014-12-17 14:09:05 +0000 | [diff] [blame] | 386 | int BytesSent() const { |
nisse | c8ee882 | 2017-01-18 07:20:55 -0800 | [diff] [blame] | 387 | RTC_CHECK(called_); |
tommi@webrtc.org | 209df9b | 2014-12-17 14:09:05 +0000 | [diff] [blame] | 388 | return stats_.bytes_sent; |
buildbot@webrtc.org | b4c7b09 | 2014-08-25 12:11:58 +0000 | [diff] [blame] | 389 | } |
| 390 | |
Fredrik Solenberg | 73276ad | 2017-09-14 14:46:47 +0200 | [diff] [blame] | 391 | int64_t CaptureStartNtpTime() const { |
| 392 | RTC_CHECK(called_); |
| 393 | return stats_.capture_start_ntp_time; |
| 394 | } |
| 395 | |
tommi@webrtc.org | 209df9b | 2014-12-17 14:09:05 +0000 | [diff] [blame] | 396 | int AvailableReceiveBandwidth() const { |
nisse | c8ee882 | 2017-01-18 07:20:55 -0800 | [diff] [blame] | 397 | RTC_CHECK(called_); |
tommi@webrtc.org | 209df9b | 2014-12-17 14:09:05 +0000 | [diff] [blame] | 398 | return stats_.available_receive_bandwidth; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 399 | } |
| 400 | |
pthatcher@webrtc.org | 7bea1ff | 2015-03-04 01:38:30 +0000 | [diff] [blame] | 401 | std::string DtlsCipher() const { |
nisse | c8ee882 | 2017-01-18 07:20:55 -0800 | [diff] [blame] | 402 | RTC_CHECK(called_); |
pthatcher@webrtc.org | 7bea1ff | 2015-03-04 01:38:30 +0000 | [diff] [blame] | 403 | return stats_.dtls_cipher; |
| 404 | } |
| 405 | |
| 406 | std::string SrtpCipher() const { |
nisse | c8ee882 | 2017-01-18 07:20:55 -0800 | [diff] [blame] | 407 | RTC_CHECK(called_); |
pthatcher@webrtc.org | 7bea1ff | 2015-03-04 01:38:30 +0000 | [diff] [blame] | 408 | return stats_.srtp_cipher; |
| 409 | } |
| 410 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 411 | private: |
tommi@webrtc.org | 209df9b | 2014-12-17 14:09:05 +0000 | [diff] [blame] | 412 | bool GetIntValue(const StatsReport* report, |
| 413 | StatsReport::StatsValueName name, |
| 414 | int* value) { |
tommi@webrtc.org | 92f4018 | 2015-03-04 15:25:19 +0000 | [diff] [blame] | 415 | const StatsReport::Value* v = report->FindValue(name); |
| 416 | if (v) { |
| 417 | // TODO(tommi): We should really just be using an int here :-/ |
| 418 | *value = rtc::FromString<int>(v->ToString()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 419 | } |
tommi@webrtc.org | 92f4018 | 2015-03-04 15:25:19 +0000 | [diff] [blame] | 420 | return v != nullptr; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 421 | } |
tommi@webrtc.org | 92f4018 | 2015-03-04 15:25:19 +0000 | [diff] [blame] | 422 | |
Fredrik Solenberg | 73276ad | 2017-09-14 14:46:47 +0200 | [diff] [blame] | 423 | bool GetInt64Value(const StatsReport* report, |
| 424 | StatsReport::StatsValueName name, |
| 425 | int64_t* value) { |
| 426 | const StatsReport::Value* v = report->FindValue(name); |
| 427 | if (v) { |
| 428 | // TODO(tommi): We should really just be using an int here :-/ |
| 429 | *value = rtc::FromString<int64_t>(v->ToString()); |
| 430 | } |
| 431 | return v != nullptr; |
| 432 | } |
| 433 | |
pthatcher@webrtc.org | 7bea1ff | 2015-03-04 01:38:30 +0000 | [diff] [blame] | 434 | bool GetStringValue(const StatsReport* report, |
| 435 | StatsReport::StatsValueName name, |
| 436 | std::string* value) { |
tommi@webrtc.org | 92f4018 | 2015-03-04 15:25:19 +0000 | [diff] [blame] | 437 | const StatsReport::Value* v = report->FindValue(name); |
| 438 | if (v) |
| 439 | *value = v->ToString(); |
| 440 | return v != nullptr; |
pthatcher@webrtc.org | 7bea1ff | 2015-03-04 01:38:30 +0000 | [diff] [blame] | 441 | } |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 442 | |
| 443 | bool called_; |
tommi@webrtc.org | 209df9b | 2014-12-17 14:09:05 +0000 | [diff] [blame] | 444 | struct { |
pthatcher@webrtc.org | 7bea1ff | 2015-03-04 01:38:30 +0000 | [diff] [blame] | 445 | void Clear() { |
| 446 | number_of_reports = 0; |
jbauch | be24c94 | 2015-06-22 15:06:43 -0700 | [diff] [blame] | 447 | timestamp = 0; |
pthatcher@webrtc.org | 7bea1ff | 2015-03-04 01:38:30 +0000 | [diff] [blame] | 448 | audio_output_level = 0; |
| 449 | audio_input_level = 0; |
| 450 | bytes_received = 0; |
| 451 | bytes_sent = 0; |
Fredrik Solenberg | 73276ad | 2017-09-14 14:46:47 +0200 | [diff] [blame] | 452 | capture_start_ntp_time = 0; |
pthatcher@webrtc.org | 7bea1ff | 2015-03-04 01:38:30 +0000 | [diff] [blame] | 453 | available_receive_bandwidth = 0; |
| 454 | dtls_cipher.clear(); |
| 455 | srtp_cipher.clear(); |
| 456 | } |
| 457 | |
tommi@webrtc.org | 209df9b | 2014-12-17 14:09:05 +0000 | [diff] [blame] | 458 | size_t number_of_reports; |
jbauch | be24c94 | 2015-06-22 15:06:43 -0700 | [diff] [blame] | 459 | double timestamp; |
tommi@webrtc.org | 209df9b | 2014-12-17 14:09:05 +0000 | [diff] [blame] | 460 | int audio_output_level; |
| 461 | int audio_input_level; |
| 462 | int bytes_received; |
| 463 | int bytes_sent; |
Fredrik Solenberg | 73276ad | 2017-09-14 14:46:47 +0200 | [diff] [blame] | 464 | int64_t capture_start_ntp_time; |
tommi@webrtc.org | 209df9b | 2014-12-17 14:09:05 +0000 | [diff] [blame] | 465 | int available_receive_bandwidth; |
pthatcher@webrtc.org | 7bea1ff | 2015-03-04 01:38:30 +0000 | [diff] [blame] | 466 | std::string dtls_cipher; |
| 467 | std::string srtp_cipher; |
tommi@webrtc.org | 209df9b | 2014-12-17 14:09:05 +0000 | [diff] [blame] | 468 | } stats_; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 469 | }; |
| 470 | |
deadbeef | d8ad788 | 2017-04-18 16:01:17 -0700 | [diff] [blame] | 471 | // Helper class that just stores the report from the callback. |
| 472 | class MockRTCStatsCollectorCallback : public webrtc::RTCStatsCollectorCallback { |
| 473 | public: |
| 474 | rtc::scoped_refptr<const RTCStatsReport> report() { return report_; } |
| 475 | |
| 476 | bool called() const { return called_; } |
| 477 | |
| 478 | protected: |
| 479 | void OnStatsDelivered( |
| 480 | const rtc::scoped_refptr<const RTCStatsReport>& report) override { |
| 481 | report_ = report; |
| 482 | called_ = true; |
| 483 | } |
| 484 | |
| 485 | private: |
| 486 | bool called_ = false; |
| 487 | rtc::scoped_refptr<const RTCStatsReport> report_; |
| 488 | }; |
| 489 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 490 | } // namespace webrtc |
| 491 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 492 | #endif // PC_TEST_MOCKPEERCONNECTIONOBSERVERS_H_ |