OLD | NEW |
| (Empty) |
1 /* | |
2 * Copyright 2016 The WebRTC project authors. All Rights Reserved. | |
3 * | |
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. | |
9 */ | |
10 | |
11 #include "webrtc/stats/rtcstatscollector.h" | |
12 | |
13 #include <memory> | |
14 #include <string> | |
15 #include <vector> | |
16 | |
17 #include "webrtc/api/jsepsessiondescription.h" | |
18 #include "webrtc/api/rtcstats_objects.h" | |
19 #include "webrtc/api/rtcstatsreport.h" | |
20 #include "webrtc/api/test/mock_datachannel.h" | |
21 #include "webrtc/api/test/mock_peerconnection.h" | |
22 #include "webrtc/api/test/mock_webrtcsession.h" | |
23 #include "webrtc/base/checks.h" | |
24 #include "webrtc/base/fakeclock.h" | |
25 #include "webrtc/base/gunit.h" | |
26 #include "webrtc/base/logging.h" | |
27 #include "webrtc/base/thread_checker.h" | |
28 #include "webrtc/base/timedelta.h" | |
29 #include "webrtc/base/timeutils.h" | |
30 #include "webrtc/base/timing.h" | |
31 #include "webrtc/media/base/fakemediaengine.h" | |
32 | |
33 using testing::Return; | |
34 using testing::ReturnRef; | |
35 | |
36 namespace webrtc { | |
37 | |
38 namespace { | |
39 | |
40 const int64_t kGetStatsReportTimeoutMs = 1000; | |
41 | |
42 class RTCStatsCollectorTestHelper : public SetSessionDescriptionObserver { | |
43 public: | |
44 RTCStatsCollectorTestHelper() | |
45 : worker_thread_(rtc::Thread::Current()), | |
46 network_thread_(rtc::Thread::Current()), | |
47 channel_manager_(new cricket::ChannelManager( | |
48 new cricket::FakeMediaEngine(), | |
49 worker_thread_, | |
50 network_thread_)), | |
51 media_controller_( | |
52 MediaControllerInterface::Create(cricket::MediaConfig(), | |
53 worker_thread_, | |
54 channel_manager_.get())), | |
55 session_(media_controller_.get()), | |
56 pc_() { | |
57 EXPECT_CALL(pc_, session()).WillRepeatedly(Return(&session_)); | |
58 EXPECT_CALL(pc_, sctp_data_channels()).WillRepeatedly( | |
59 ReturnRef(data_channels_)); | |
60 } | |
61 | |
62 MockWebRtcSession& session() { return session_; } | |
63 MockPeerConnection& pc() { return pc_; } | |
64 std::vector<rtc::scoped_refptr<DataChannel>>& data_channels() { | |
65 return data_channels_; | |
66 } | |
67 | |
68 // SetSessionDescriptionObserver overrides. | |
69 void OnSuccess() override {} | |
70 void OnFailure(const std::string& error) override { | |
71 RTC_NOTREACHED() << error; | |
72 } | |
73 | |
74 private: | |
75 rtc::Thread* const worker_thread_; | |
76 rtc::Thread* const network_thread_; | |
77 std::unique_ptr<cricket::ChannelManager> channel_manager_; | |
78 std::unique_ptr<webrtc::MediaControllerInterface> media_controller_; | |
79 MockWebRtcSession session_; | |
80 MockPeerConnection pc_; | |
81 | |
82 std::vector<rtc::scoped_refptr<DataChannel>> data_channels_; | |
83 }; | |
84 | |
85 class RTCTestStats : public RTCStats { | |
86 public: | |
87 RTCTestStats(const std::string& id, int64_t timestamp_us) | |
88 : RTCStats(id, timestamp_us), | |
89 dummy_stat("dummyStat") {} | |
90 | |
91 WEBRTC_RTCSTATS_IMPL(RTCStats, RTCTestStats, | |
92 &dummy_stat); | |
93 | |
94 RTCStatsMember<int32_t> dummy_stat; | |
95 }; | |
96 | |
97 const char RTCTestStats::kType[] = "test-stats"; | |
98 | |
99 // Overrides the stats collection to verify thread usage and that the resulting | |
100 // partial reports are merged. | |
101 class FakeRTCStatsCollector : public RTCStatsCollector, | |
102 public RTCStatsCollectorCallback { | |
103 public: | |
104 static rtc::scoped_refptr<FakeRTCStatsCollector> Create( | |
105 PeerConnection* pc, | |
106 int64_t cache_lifetime_us) { | |
107 return rtc::scoped_refptr<FakeRTCStatsCollector>( | |
108 new rtc::RefCountedObject<FakeRTCStatsCollector>( | |
109 pc, cache_lifetime_us)); | |
110 } | |
111 | |
112 // RTCStatsCollectorCallback implementation. | |
113 void OnStatsDelivered( | |
114 const rtc::scoped_refptr<const RTCStatsReport>& report) override { | |
115 EXPECT_TRUE(signaling_thread_->IsCurrent()); | |
116 rtc::CritScope cs(&lock_); | |
117 delivered_report_ = report; | |
118 } | |
119 | |
120 void VerifyThreadUsageAndResultsMerging() { | |
121 GetStatsReport(rtc::scoped_refptr<RTCStatsCollectorCallback>(this)); | |
122 EXPECT_TRUE_WAIT(HasVerifiedResults(), kGetStatsReportTimeoutMs); | |
123 } | |
124 | |
125 bool HasVerifiedResults() { | |
126 EXPECT_TRUE(signaling_thread_->IsCurrent()); | |
127 rtc::CritScope cs(&lock_); | |
128 if (!delivered_report_) | |
129 return false; | |
130 EXPECT_EQ(produced_on_signaling_thread_, 1); | |
131 EXPECT_EQ(produced_on_worker_thread_, 1); | |
132 EXPECT_EQ(produced_on_network_thread_, 1); | |
133 | |
134 EXPECT_TRUE(delivered_report_->Get("SignalingThreadStats")); | |
135 EXPECT_TRUE(delivered_report_->Get("WorkerThreadStats")); | |
136 EXPECT_TRUE(delivered_report_->Get("NetworkThreadStats")); | |
137 | |
138 produced_on_signaling_thread_ = 0; | |
139 produced_on_worker_thread_ = 0; | |
140 produced_on_network_thread_ = 0; | |
141 delivered_report_ = nullptr; | |
142 return true; | |
143 } | |
144 | |
145 protected: | |
146 FakeRTCStatsCollector( | |
147 PeerConnection* pc, | |
148 int64_t cache_lifetime) | |
149 : RTCStatsCollector(pc, cache_lifetime), | |
150 signaling_thread_(pc->session()->signaling_thread()), | |
151 worker_thread_(pc->session()->worker_thread()), | |
152 network_thread_(pc->session()->network_thread()) { | |
153 } | |
154 | |
155 void ProducePartialResultsOnSignalingThread(int64_t timestamp_us) override { | |
156 EXPECT_TRUE(signaling_thread_->IsCurrent()); | |
157 { | |
158 rtc::CritScope cs(&lock_); | |
159 EXPECT_FALSE(delivered_report_); | |
160 ++produced_on_signaling_thread_; | |
161 } | |
162 | |
163 rtc::scoped_refptr<RTCStatsReport> signaling_report = | |
164 RTCStatsReport::Create(); | |
165 signaling_report->AddStats(std::unique_ptr<const RTCStats>( | |
166 new RTCTestStats("SignalingThreadStats", timestamp_us))); | |
167 AddPartialResults(signaling_report); | |
168 } | |
169 void ProducePartialResultsOnWorkerThread(int64_t timestamp_us) override { | |
170 EXPECT_TRUE(worker_thread_->IsCurrent()); | |
171 { | |
172 rtc::CritScope cs(&lock_); | |
173 EXPECT_FALSE(delivered_report_); | |
174 ++produced_on_worker_thread_; | |
175 } | |
176 | |
177 rtc::scoped_refptr<RTCStatsReport> worker_report = RTCStatsReport::Create(); | |
178 worker_report->AddStats(std::unique_ptr<const RTCStats>( | |
179 new RTCTestStats("WorkerThreadStats", timestamp_us))); | |
180 AddPartialResults(worker_report); | |
181 } | |
182 void ProducePartialResultsOnNetworkThread(int64_t timestamp_us) override { | |
183 EXPECT_TRUE(network_thread_->IsCurrent()); | |
184 { | |
185 rtc::CritScope cs(&lock_); | |
186 EXPECT_FALSE(delivered_report_); | |
187 ++produced_on_network_thread_; | |
188 } | |
189 | |
190 rtc::scoped_refptr<RTCStatsReport> network_report = | |
191 RTCStatsReport::Create(); | |
192 network_report->AddStats(std::unique_ptr<const RTCStats>( | |
193 new RTCTestStats("NetworkThreadStats", timestamp_us))); | |
194 AddPartialResults(network_report); | |
195 } | |
196 | |
197 private: | |
198 rtc::Thread* const signaling_thread_; | |
199 rtc::Thread* const worker_thread_; | |
200 rtc::Thread* const network_thread_; | |
201 | |
202 rtc::CriticalSection lock_; | |
203 rtc::scoped_refptr<const RTCStatsReport> delivered_report_; | |
204 int produced_on_signaling_thread_ = 0; | |
205 int produced_on_worker_thread_ = 0; | |
206 int produced_on_network_thread_ = 0; | |
207 }; | |
208 | |
209 class StatsCallback : public RTCStatsCollectorCallback { | |
210 public: | |
211 static rtc::scoped_refptr<StatsCallback> Create( | |
212 rtc::scoped_refptr<const RTCStatsReport>* report_ptr = nullptr) { | |
213 return rtc::scoped_refptr<StatsCallback>( | |
214 new rtc::RefCountedObject<StatsCallback>(report_ptr)); | |
215 } | |
216 | |
217 void OnStatsDelivered( | |
218 const rtc::scoped_refptr<const RTCStatsReport>& report) override { | |
219 EXPECT_TRUE(thread_checker_.CalledOnValidThread()); | |
220 report_ = report; | |
221 if (report_ptr_) | |
222 *report_ptr_ = report_; | |
223 } | |
224 | |
225 rtc::scoped_refptr<const RTCStatsReport> report() const { | |
226 EXPECT_TRUE(thread_checker_.CalledOnValidThread()); | |
227 return report_; | |
228 } | |
229 | |
230 protected: | |
231 explicit StatsCallback(rtc::scoped_refptr<const RTCStatsReport>* report_ptr) | |
232 : report_ptr_(report_ptr) {} | |
233 | |
234 private: | |
235 rtc::ThreadChecker thread_checker_; | |
236 rtc::scoped_refptr<const RTCStatsReport> report_; | |
237 rtc::scoped_refptr<const RTCStatsReport>* report_ptr_; | |
238 }; | |
239 | |
240 class RTCStatsCollectorTest : public testing::Test { | |
241 public: | |
242 RTCStatsCollectorTest() | |
243 : test_(new rtc::RefCountedObject<RTCStatsCollectorTestHelper>()), | |
244 collector_(RTCStatsCollector::Create( | |
245 &test_->pc(), 50 * rtc::kNumMicrosecsPerMillisec)) { | |
246 } | |
247 | |
248 rtc::scoped_refptr<const RTCStatsReport> GetStatsReport() { | |
249 rtc::scoped_refptr<StatsCallback> callback = StatsCallback::Create(); | |
250 collector_->GetStatsReport(callback); | |
251 EXPECT_TRUE_WAIT(callback->report(), kGetStatsReportTimeoutMs); | |
252 return callback->report(); | |
253 } | |
254 | |
255 protected: | |
256 rtc::scoped_refptr<RTCStatsCollectorTestHelper> test_; | |
257 rtc::scoped_refptr<RTCStatsCollector> collector_; | |
258 }; | |
259 | |
260 TEST_F(RTCStatsCollectorTest, SingleCallback) { | |
261 rtc::scoped_refptr<const RTCStatsReport> result; | |
262 collector_->GetStatsReport(StatsCallback::Create(&result)); | |
263 EXPECT_TRUE_WAIT(result, kGetStatsReportTimeoutMs); | |
264 } | |
265 | |
266 TEST_F(RTCStatsCollectorTest, MultipleCallbacks) { | |
267 rtc::scoped_refptr<const RTCStatsReport> a; | |
268 rtc::scoped_refptr<const RTCStatsReport> b; | |
269 rtc::scoped_refptr<const RTCStatsReport> c; | |
270 collector_->GetStatsReport(StatsCallback::Create(&a)); | |
271 collector_->GetStatsReport(StatsCallback::Create(&b)); | |
272 collector_->GetStatsReport(StatsCallback::Create(&c)); | |
273 EXPECT_TRUE_WAIT(a, kGetStatsReportTimeoutMs); | |
274 EXPECT_TRUE_WAIT(b, kGetStatsReportTimeoutMs); | |
275 EXPECT_TRUE_WAIT(c, kGetStatsReportTimeoutMs); | |
276 EXPECT_EQ(a.get(), b.get()); | |
277 EXPECT_EQ(b.get(), c.get()); | |
278 } | |
279 | |
280 TEST_F(RTCStatsCollectorTest, CachedStatsReports) { | |
281 rtc::ScopedFakeClock fake_clock; | |
282 // Caching should ensure |a| and |b| are the same report. | |
283 rtc::scoped_refptr<const RTCStatsReport> a = GetStatsReport(); | |
284 rtc::scoped_refptr<const RTCStatsReport> b = GetStatsReport(); | |
285 EXPECT_EQ(a.get(), b.get()); | |
286 // Invalidate cache by clearing it. | |
287 collector_->ClearCachedStatsReport(); | |
288 rtc::scoped_refptr<const RTCStatsReport> c = GetStatsReport(); | |
289 EXPECT_NE(b.get(), c.get()); | |
290 // Invalidate cache by advancing time. | |
291 fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(51)); | |
292 rtc::scoped_refptr<const RTCStatsReport> d = GetStatsReport(); | |
293 EXPECT_TRUE(d); | |
294 EXPECT_NE(c.get(), d.get()); | |
295 } | |
296 | |
297 TEST_F(RTCStatsCollectorTest, MultipleCallbacksWithInvalidatedCacheInBetween) { | |
298 rtc::ScopedFakeClock fake_clock; | |
299 rtc::scoped_refptr<const RTCStatsReport> a; | |
300 rtc::scoped_refptr<const RTCStatsReport> b; | |
301 rtc::scoped_refptr<const RTCStatsReport> c; | |
302 collector_->GetStatsReport(StatsCallback::Create(&a)); | |
303 collector_->GetStatsReport(StatsCallback::Create(&b)); | |
304 // Cache is invalidated after 50 ms. | |
305 fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(51)); | |
306 collector_->GetStatsReport(StatsCallback::Create(&c)); | |
307 EXPECT_TRUE_WAIT(a, kGetStatsReportTimeoutMs); | |
308 EXPECT_TRUE_WAIT(b, kGetStatsReportTimeoutMs); | |
309 EXPECT_TRUE_WAIT(c, kGetStatsReportTimeoutMs); | |
310 EXPECT_EQ(a.get(), b.get()); | |
311 // The act of doing |AdvanceTime| processes all messages. If this was not the | |
312 // case we might not require |c| to be fresher than |b|. | |
313 EXPECT_NE(c.get(), b.get()); | |
314 } | |
315 | |
316 TEST_F(RTCStatsCollectorTest, CollectRTCPeerConnectionStats) { | |
317 int64_t before = static_cast<int64_t>( | |
318 rtc::Timing::WallTimeNow() * rtc::kNumMicrosecsPerSec); | |
319 rtc::scoped_refptr<const RTCStatsReport> report = GetStatsReport(); | |
320 int64_t after = static_cast<int64_t>( | |
321 rtc::Timing::WallTimeNow() * rtc::kNumMicrosecsPerSec); | |
322 EXPECT_EQ(report->GetStatsOfType<RTCPeerConnectionStats>().size(), | |
323 static_cast<size_t>(1)) << "Expecting 1 RTCPeerConnectionStats."; | |
324 const RTCStats* stats = report->Get("RTCPeerConnection"); | |
325 EXPECT_TRUE(stats); | |
326 EXPECT_LE(before, stats->timestamp_us()); | |
327 EXPECT_LE(stats->timestamp_us(), after); | |
328 { | |
329 // Expected stats with no data channels | |
330 const RTCPeerConnectionStats& pcstats = | |
331 stats->cast_to<RTCPeerConnectionStats>(); | |
332 EXPECT_EQ(*pcstats.data_channels_opened, static_cast<uint32_t>(0)); | |
333 EXPECT_EQ(*pcstats.data_channels_closed, static_cast<uint32_t>(0)); | |
334 } | |
335 | |
336 test_->data_channels().push_back( | |
337 new MockDataChannel(DataChannelInterface::kConnecting)); | |
338 test_->data_channels().push_back( | |
339 new MockDataChannel(DataChannelInterface::kOpen)); | |
340 test_->data_channels().push_back( | |
341 new MockDataChannel(DataChannelInterface::kClosing)); | |
342 test_->data_channels().push_back( | |
343 new MockDataChannel(DataChannelInterface::kClosed)); | |
344 | |
345 collector_->ClearCachedStatsReport(); | |
346 report = GetStatsReport(); | |
347 EXPECT_EQ(report->GetStatsOfType<RTCPeerConnectionStats>().size(), | |
348 static_cast<size_t>(1)) << "Expecting 1 RTCPeerConnectionStats."; | |
349 stats = report->Get("RTCPeerConnection"); | |
350 EXPECT_TRUE(stats); | |
351 { | |
352 // Expected stats with the above four data channels | |
353 // TODO(hbos): When the |RTCPeerConnectionStats| is the number of data | |
354 // channels that have been opened and closed, not the numbers currently | |
355 // open/closed, we would expect opened >= closed and (opened - closed) to be | |
356 // the number currently open. crbug.com/636818. | |
357 const RTCPeerConnectionStats& pcstats = | |
358 stats->cast_to<RTCPeerConnectionStats>(); | |
359 EXPECT_EQ(*pcstats.data_channels_opened, static_cast<uint32_t>(1)); | |
360 EXPECT_EQ(*pcstats.data_channels_closed, static_cast<uint32_t>(3)); | |
361 } | |
362 } | |
363 | |
364 class RTCStatsCollectorTestWithFakeCollector : public testing::Test { | |
365 public: | |
366 RTCStatsCollectorTestWithFakeCollector() | |
367 : test_(new rtc::RefCountedObject<RTCStatsCollectorTestHelper>()), | |
368 collector_(FakeRTCStatsCollector::Create( | |
369 &test_->pc(), 50 * rtc::kNumMicrosecsPerMillisec)) { | |
370 } | |
371 | |
372 protected: | |
373 rtc::scoped_refptr<RTCStatsCollectorTestHelper> test_; | |
374 rtc::scoped_refptr<FakeRTCStatsCollector> collector_; | |
375 }; | |
376 | |
377 TEST_F(RTCStatsCollectorTestWithFakeCollector, ThreadUsageAndResultsMerging) { | |
378 collector_->VerifyThreadUsageAndResultsMerging(); | |
379 } | |
380 | |
381 } // namespace | |
382 | |
383 } // namespace webrtc | |
OLD | NEW |