RTCStatsCollector and RTCPeerConnectionStats added.
This is the stats collector for the new stats types, RTCStats[1] and
RTCStatsReport[2]. It so far only produces RTCPeerConnectionStats[3] as
an example of how it would collect stats. Each RTCStats subclass will
get a corresponding RTCStatsCollector::ProduceFooStats().
Stats reports are cached and returned as const references (ref
counting). This allows stats to be inspected by multiple observers and
across multiple threads. No copies will have to be made when surfacing
this to Blink or other places.
The current implementation of ProducePeerConnectionStats() only look at
existing DataChannels. This might be incorret if data channels can be
removed? Will investigate in a follow-up, crbug.com/636818.
[1] https://www.w3.org/TR/2016/WD-webrtc-20160531/#idl-def-rtcstats
[2] https://www.w3.org/TR/2016/WD-webrtc-20160531/#rtcstatsreport-object
[3] https://w3c.github.io/webrtc-stats/archives/20160526/webrtc-stats.html#pcstats-dict*
BUG=chromium:627816, chromium:636818
Review-Url: https://codereview.webrtc.org/2242043002
Cr-Commit-Position: refs/heads/master@{#13979}
diff --git a/webrtc/stats/rtcstatscollector_unittest.cc b/webrtc/stats/rtcstatscollector_unittest.cc
new file mode 100644
index 0000000..a3b0572
--- /dev/null
+++ b/webrtc/stats/rtcstatscollector_unittest.cc
@@ -0,0 +1,152 @@
+/*
+ * Copyright 2016 The WebRTC project authors. All Rights Reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE file in the root of the source
+ * tree. An additional intellectual property rights grant can be found
+ * in the file PATENTS. All contributing project authors may
+ * be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "webrtc/stats/rtcstatscollector.h"
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "webrtc/api/jsepsessiondescription.h"
+#include "webrtc/api/rtcstats_objects.h"
+#include "webrtc/api/rtcstatsreport.h"
+#include "webrtc/api/test/mock_datachannel.h"
+#include "webrtc/api/test/mock_peerconnection.h"
+#include "webrtc/api/test/mock_webrtcsession.h"
+#include "webrtc/base/checks.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/test/faketiming.h"
+#include "webrtc/media/base/fakemediaengine.h"
+
+using testing::Return;
+using testing::ReturnRef;
+
+namespace webrtc {
+
+class RTCStatsCollectorTester : public SetSessionDescriptionObserver {
+ public:
+ RTCStatsCollectorTester()
+ : worker_thread_(rtc::Thread::Current()),
+ network_thread_(rtc::Thread::Current()),
+ channel_manager_(new cricket::ChannelManager(
+ new cricket::FakeMediaEngine(),
+ worker_thread_,
+ network_thread_)),
+ media_controller_(
+ MediaControllerInterface::Create(cricket::MediaConfig(),
+ worker_thread_,
+ channel_manager_.get())),
+ session_(media_controller_.get()),
+ pc_() {
+ EXPECT_CALL(pc_, session()).WillRepeatedly(Return(&session_));
+ EXPECT_CALL(pc_, sctp_data_channels()).WillRepeatedly(
+ ReturnRef(data_channels_));
+ }
+
+ MockWebRtcSession& session() { return session_; }
+ MockPeerConnection& pc() { return pc_; }
+ std::vector<rtc::scoped_refptr<DataChannel>>& data_channels() {
+ return data_channels_;
+ }
+
+ // SetSessionDescriptionObserver overrides.
+ void OnSuccess() override {}
+ void OnFailure(const std::string& error) override {
+ RTC_NOTREACHED() << error;
+ }
+
+ private:
+ rtc::Thread* const worker_thread_;
+ rtc::Thread* const network_thread_;
+ std::unique_ptr<cricket::ChannelManager> channel_manager_;
+ std::unique_ptr<webrtc::MediaControllerInterface> media_controller_;
+ MockWebRtcSession session_;
+ MockPeerConnection pc_;
+
+ std::vector<rtc::scoped_refptr<DataChannel>> data_channels_;
+};
+
+class RTCStatsCollectorTest : public testing::Test {
+ public:
+ RTCStatsCollectorTest()
+ : test_(new rtc::RefCountedObject<RTCStatsCollectorTester>()),
+ timing_(new rtc::FakeTiming()),
+ collector_(&test_->pc(), 0.05, std::unique_ptr<rtc::Timing>(timing_)) {
+ }
+
+ protected:
+ rtc::scoped_refptr<RTCStatsCollectorTester> test_;
+ rtc::FakeTiming* timing_; // Owned by |collector_|.
+ RTCStatsCollector collector_;
+};
+
+TEST_F(RTCStatsCollectorTest, CachedStatsReport) {
+ // Caching should ensure |a| and |b| are the same report.
+ rtc::scoped_refptr<const RTCStatsReport> a = collector_.GetStatsReport();
+ rtc::scoped_refptr<const RTCStatsReport> b = collector_.GetStatsReport();
+ EXPECT_TRUE(a);
+ EXPECT_EQ(a.get(), b.get());
+ // Invalidate cache by clearing it.
+ collector_.ClearCachedStatsReport();
+ rtc::scoped_refptr<const RTCStatsReport> c = collector_.GetStatsReport();
+ EXPECT_TRUE(c);
+ EXPECT_NE(b.get(), c.get());
+ // Invalidate cache by advancing time.
+ timing_->AdvanceTimeMillisecs(51.0);
+ rtc::scoped_refptr<const RTCStatsReport> d = collector_.GetStatsReport();
+ EXPECT_TRUE(d);
+ EXPECT_NE(c.get(), d.get());
+}
+
+TEST_F(RTCStatsCollectorTest, CollectRTCPeerConnectionStats) {
+ rtc::scoped_refptr<const RTCStatsReport> report = collector_.GetStatsReport();
+ EXPECT_EQ(report->GetStatsOfType<RTCPeerConnectionStats>().size(),
+ static_cast<size_t>(1)) << "Expecting 1 RTCPeerConnectionStats.";
+ const RTCStats* stats = report->Get("RTCPeerConnection");
+ EXPECT_TRUE(stats);
+ EXPECT_EQ(stats->timestamp(), timing_->TimerNow());
+ {
+ // Expected stats with no data channels
+ const RTCPeerConnectionStats& pcstats =
+ stats->cast_to<RTCPeerConnectionStats>();
+ EXPECT_EQ(*pcstats.data_channels_opened, static_cast<uint32_t>(0));
+ EXPECT_EQ(*pcstats.data_channels_closed, static_cast<uint32_t>(0));
+ }
+
+ test_->data_channels().push_back(
+ new MockDataChannel(DataChannelInterface::kConnecting));
+ test_->data_channels().push_back(
+ new MockDataChannel(DataChannelInterface::kOpen));
+ test_->data_channels().push_back(
+ new MockDataChannel(DataChannelInterface::kClosing));
+ test_->data_channels().push_back(
+ new MockDataChannel(DataChannelInterface::kClosed));
+
+ collector_.ClearCachedStatsReport();
+ report = collector_.GetStatsReport();
+ EXPECT_EQ(report->GetStatsOfType<RTCPeerConnectionStats>().size(),
+ static_cast<size_t>(1)) << "Expecting 1 RTCPeerConnectionStats.";
+ stats = report->Get("RTCPeerConnection");
+ EXPECT_TRUE(stats);
+ {
+ // Expected stats with the above four data channels
+ // TODO(hbos): When the |RTCPeerConnectionStats| is the number of data
+ // channels that have been opened and closed, not the numbers currently
+ // open/closed, we would expect opened >= closed and (opened - closed) to be
+ // the number currently open. crbug.com/636818.
+ const RTCPeerConnectionStats& pcstats =
+ stats->cast_to<RTCPeerConnectionStats>();
+ EXPECT_EQ(*pcstats.data_channels_opened, static_cast<uint32_t>(1));
+ EXPECT_EQ(*pcstats.data_channels_closed, static_cast<uint32_t>(3));
+ }
+}
+
+} // namespace webrtc
