admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Revert of RTCOutboundRTPStreamStats added. (patchset #3 id:80001 of https://codereview.webrtc.org/2456463002/ )

Browse Source 
Reason for revert:
Breaks Chrome FYI.
peerconnection_unittest calls RTCStatsReport::Create without  parameters.

Original issue's description:
> RTCOutboundRTPStreamStats[1] added.
>
> This also adds RTCRTPStreamStats[2] which it derives from. Not all stats
> are supported in this CL, this must be addressed before closing the
> issue.
>
> RTCStatsReport also gets a timestamp and ToString.
>
> [1] https://w3c.github.io/webrtc-stats/#outboundrtpstats-dict*
> [2] https://w3c.github.io/webrtc-stats/#streamstats-dict*
>
> BUG=chromium:627816, chromium:657856, chromium:657854
>
> Committed: https://crrev.com/69e9cb08285f6cbcab547c7a5e6aa668fa6f2d29
> Cr-Commit-Position: refs/heads/master@{#14860}

TBR=hta@webrtc.org,deadbeef@webrtc.org,hbos@webrtc.org
# Skipping CQ checks because original CL landed less than 1 days ago.
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=chromium:627816, chromium:657856, chromium:657854

Review-Url: https://codereview.webrtc.org/2465223002
Cr-Commit-Position: refs/heads/master@{#14863}
This commit is contained in:
perkj 2016-10-31 23:52:25 -07:00 committed by Commit bot
parent 4ed075034a
commit 7eaa83622b
10 changed files with 20 additions and 472 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

140
webrtc/api/rtcstatscollector.cc
View File

@ -17,8 +17,6 @@
#include "webrtc/api/peerconnection.h"
#include "webrtc/api/webrtcsession.h"
#include "webrtc/base/checks.h"
#include "webrtc/base/timeutils.h"
#include "webrtc/media/base/mediachannel.h"
#include "webrtc/p2p/base/candidate.h"
#include "webrtc/p2p/base/p2pconstants.h"
#include "webrtc/p2p/base/port.h"
@ -43,21 +41,6 @@ std::string RTCTransportStatsIDFromTransportChannel(
rtc::ToString<>(channel_component);
}
std::string RTCTransportStatsIDFromBaseChannel(
const ProxyTransportMap& proxy_to_transport,
const cricket::BaseChannel& base_channel) {
auto proxy_it = proxy_to_transport.find(base_channel.content_name());
if (proxy_it == proxy_to_transport.cend())
return "";
return RTCTransportStatsIDFromTransportChannel(
proxy_it->second, cricket::ICE_CANDIDATE_COMPONENT_RTP);
}
std::string RTCOutboundRTPStreamStatsIDFromSSRC(bool audio, uint32_t ssrc) {
return audio ? "RTCOutboundRTPAudioStream_" + rtc::ToString<>(ssrc)
: "RTCOutboundRTPVideoStream_" + rtc::ToString<>(ssrc);
}
const char* CandidateTypeToRTCIceCandidateType(const std::string& type) {
if (type == cricket::LOCAL_PORT_TYPE)
return RTCIceCandidateType::kHost;
@ -88,47 +71,6 @@ const char* DataStateToRTCDataChannelState(
}
}
void SetOutboundRTPStreamStatsFromMediaSenderInfo(
const cricket::MediaSenderInfo& media_sender_info,
RTCOutboundRTPStreamStats* outbound_stats) {
RTC_DCHECK(outbound_stats);
outbound_stats->ssrc = rtc::ToString<>(media_sender_info.ssrc());
// TODO(hbos): Support the remote case. crbug.com/657856
outbound_stats->is_remote = false;
// TODO(hbos): Set |codec_id| when we have |RTCCodecStats|. Maybe relevant:
// |media_sender_info.codec_name|. crbug.com/657854, 657856, 659117
outbound_stats->packets_sent =
static_cast<uint32_t>(media_sender_info.packets_sent);
outbound_stats->bytes_sent =
static_cast<uint64_t>(media_sender_info.bytes_sent);
outbound_stats->round_trip_time =
static_cast<double>(media_sender_info.rtt_ms) / rtc::kNumMillisecsPerSec;
}
void SetOutboundRTPStreamStatsFromVoiceSenderInfo(
const cricket::VoiceSenderInfo& voice_sender_info,
RTCOutboundRTPStreamStats* outbound_audio) {
SetOutboundRTPStreamStatsFromMediaSenderInfo(
voice_sender_info, outbound_audio);
outbound_audio->media_type = "audio";
// |fir_count|, |pli_count| and |sli_count| are only valid for video and are
// purposefully left undefined for audio.
}
void SetOutboundRTPStreamStatsFromVideoSenderInfo(
const cricket::VideoSenderInfo& video_sender_info,
RTCOutboundRTPStreamStats* outbound_video) {
SetOutboundRTPStreamStatsFromMediaSenderInfo(
video_sender_info, outbound_video);
outbound_video->media_type = "video";
outbound_video->fir_count =
static_cast<uint32_t>(video_sender_info.firs_rcvd);
outbound_video->pli_count =
static_cast<uint32_t>(video_sender_info.plis_rcvd);
outbound_video->nack_count =
static_cast<uint32_t>(video_sender_info.nacks_rcvd);
}
void ProduceCertificateStatsFromSSLCertificateStats(
int64_t timestamp_us, const rtc::SSLCertificateStats& certificate_stats,
RTCStatsReport* report) {
@ -242,8 +184,7 @@ void RTCStatsCollector::ClearCachedStatsReport() {
void RTCStatsCollector::ProducePartialResultsOnSignalingThread(
int64_t timestamp_us) {
RTC_DCHECK(signaling_thread_->IsCurrent());
rtc::scoped_refptr<RTCStatsReport> report = RTCStatsReport::Create(
timestamp_us);
rtc::scoped_refptr<RTCStatsReport> report = RTCStatsReport::Create();
SessionStats session_stats;
if (pc_->session()->GetTransportStats(&session_stats)) {
@ -254,8 +195,6 @@ void RTCStatsCollector::ProducePartialResultsOnSignalingThread(
timestamp_us, transport_cert_stats, report.get());
ProduceIceCandidateAndPairStats_s(
timestamp_us, session_stats, report.get());
ProduceRTPStreamStats_s(
timestamp_us, session_stats, report.get());
ProduceTransportStats_s(
timestamp_us, session_stats, transport_cert_stats, report.get());
}
@ -268,16 +207,9 @@ void RTCStatsCollector::ProducePartialResultsOnSignalingThread(
void RTCStatsCollector::ProducePartialResultsOnWorkerThread(
int64_t timestamp_us) {
RTC_DCHECK(worker_thread_->IsCurrent());
rtc::scoped_refptr<RTCStatsReport> report = RTCStatsReport::Create(
timestamp_us);
rtc::scoped_refptr<RTCStatsReport> report = RTCStatsReport::Create();
// TODO(hbos): Gather stats on worker thread.
// pc_->session()'s channels are owned by the signaling thread but there are
// some stats that are gathered on the worker thread. Instead of a synchronous
// invoke on "s->w" we could to the "w" work here asynchronously if it wasn't
// for the ownership issue. Synchronous invokes in other places makes it
// difficult to introduce locks without introducing deadlocks and the channels
// are not reference counted.
AddPartialResults(report);
}
@ -285,16 +217,9 @@ void RTCStatsCollector::ProducePartialResultsOnWorkerThread(
void RTCStatsCollector::ProducePartialResultsOnNetworkThread(
int64_t timestamp_us) {
RTC_DCHECK(network_thread_->IsCurrent());
rtc::scoped_refptr<RTCStatsReport> report = RTCStatsReport::Create(
timestamp_us);
rtc::scoped_refptr<RTCStatsReport> report = RTCStatsReport::Create();
// TODO(hbos): Gather stats on network thread.
// pc_->session()'s channels are owned by the signaling thread but there are
// some stats that are gathered on the network thread. Instead of a
// synchronous invoke on "s->n" we could to the "n" work here asynchronously
// if it wasn't for the ownership issue. Synchronous invokes in other places
// makes it difficult to introduce locks without introducing deadlocks and the
// channels are not reference counted.
AddPartialResults(report);
}
@ -412,7 +337,7 @@ void RTCStatsCollector::ProduceIceCandidateAndPairStats_s(
// smoothed according to the spec. crbug.com/633550. See
// https://w3c.github.io/webrtc-stats/#dom-rtcicecandidatepairstats-currentrtt
candidate_pair_stats->current_rtt =
static_cast<double>(info.rtt) / rtc::kNumMillisecsPerSec;
static_cast<double>(info.rtt) / 1000.0;
candidate_pair_stats->requests_sent =
static_cast<uint64_t>(info.sent_ping_requests_total);
candidate_pair_stats->responses_received =
@ -449,63 +374,6 @@ void RTCStatsCollector::ProducePeerConnectionStats_s(
report->AddStats(std::move(stats));
}
void RTCStatsCollector::ProduceRTPStreamStats_s(
int64_t timestamp_us, const SessionStats& session_stats,
RTCStatsReport* report) const {
RTC_DCHECK(signaling_thread_->IsCurrent());
// Audio
if (pc_->session()->voice_channel()) {
cricket::VoiceMediaInfo voice_media_info;
if (pc_->session()->voice_channel()->GetStats(&voice_media_info)) {
std::string transport_id = RTCTransportStatsIDFromBaseChannel(
session_stats.proxy_to_transport, *pc_->session()->voice_channel());
for (const cricket::VoiceSenderInfo& voice_sender_info :
voice_media_info.senders) {
// TODO(nisse): SSRC == 0 currently means none. Delete check when that
// is fixed.
if (voice_sender_info.ssrc() == 0)
continue;
std::unique_ptr<RTCOutboundRTPStreamStats> outbound_audio(
new RTCOutboundRTPStreamStats(
RTCOutboundRTPStreamStatsIDFromSSRC(
true, voice_sender_info.ssrc()),
timestamp_us));
SetOutboundRTPStreamStatsFromVoiceSenderInfo(
voice_sender_info, outbound_audio.get());
if (!transport_id.empty())
outbound_audio->transport_id = transport_id;
report->AddStats(std::move(outbound_audio));
}
}
}
// Video
if (pc_->session()->video_channel()) {
cricket::VideoMediaInfo video_media_info;
if (pc_->session()->video_channel()->GetStats(&video_media_info)) {
std::string transport_id = RTCTransportStatsIDFromBaseChannel(
session_stats.proxy_to_transport, *pc_->session()->video_channel());
for (const cricket::VideoSenderInfo& video_sender_info :
video_media_info.senders) {
// TODO(nisse): SSRC == 0 currently means none. Delete check when that
// is fixed.
if (video_sender_info.ssrc() == 0)
continue;
std::unique_ptr<RTCOutboundRTPStreamStats> outbound_video(
new RTCOutboundRTPStreamStats(
RTCOutboundRTPStreamStatsIDFromSSRC(
false, video_sender_info.ssrc()),
timestamp_us));
SetOutboundRTPStreamStatsFromVideoSenderInfo(
video_sender_info, outbound_video.get());
if (!transport_id.empty())
outbound_video->transport_id = transport_id;
report->AddStats(std::move(outbound_video));
}
}
}
}
void RTCStatsCollector::ProduceTransportStats_s(
int64_t timestamp_us, const SessionStats& session_stats,
const std::map<std::string, CertificateStatsPair>& transport_cert_stats,

6
webrtc/api/rtcstatscollector.h
View File

@ -101,12 +101,6 @@ class RTCStatsCollector : public virtual rtc::RefCountInterface {
// Produces |RTCPeerConnectionStats|.
void ProducePeerConnectionStats_s(
int64_t timestamp_us, RTCStatsReport* report) const;
// Produces |RTCOutboundRTPStreamStats|. TODO(hbos): Produce both types of
// |RTCRTPStreamStats|, the other one being |RTCInboundRTPStreamStats|.
// crbug.com/657855
void ProduceRTPStreamStats_s(
int64_t timestamp_us, const SessionStats& session_stats,
RTCStatsReport* report) const;
// Produces |RTCTransportStats|.
void ProduceTransportStats_s(
int64_t timestamp_us, const SessionStats& session_stats,

147
webrtc/api/rtcstatscollector_unittest.cc
View File

@ -32,16 +32,13 @@
#include "webrtc/base/timeutils.h"
#include "webrtc/logging/rtc_event_log/rtc_event_log.h"
#include "webrtc/media/base/fakemediaengine.h"
#include "webrtc/media/base/test/mock_mediachannel.h"
#include "webrtc/p2p/base/p2pconstants.h"
#include "webrtc/p2p/base/port.h"
using testing::_;
using testing::Invoke;
using testing::Return;
using testing::ReturnNull;
using testing::ReturnRef;
using testing::SetArgPointee;
namespace webrtc {
@ -70,10 +67,6 @@ void PrintTo(const RTCPeerConnectionStats& stats, ::std::ostream* os) {
*os << stats.ToString();
}
void PrintTo(const RTCOutboundRTPStreamStats& stats, ::std::ostream* os) {
*os << stats.ToString();
}
void PrintTo(const RTCTransportStats& stats, ::std::ostream* os) {
*os << stats.ToString();
}
@ -151,9 +144,8 @@ class RTCStatsCollectorTestHelper : public SetSessionDescriptionObserver {
RTCStatsCollectorTestHelper()
: worker_thread_(rtc::Thread::Current()),
network_thread_(rtc::Thread::Current()),
media_engine_(new cricket::FakeMediaEngine()),
channel_manager_(
new cricket::ChannelManager(media_engine_,
new cricket::ChannelManager(new cricket::FakeMediaEngine(),
worker_thread_,
network_thread_)),
media_controller_(
@ -167,8 +159,6 @@ class RTCStatsCollectorTestHelper : public SetSessionDescriptionObserver {
EXPECT_CALL(pc_, session()).WillRepeatedly(Return(&session_));
EXPECT_CALL(pc_, sctp_data_channels()).WillRepeatedly(
ReturnRef(data_channels_));
EXPECT_CALL(session_, video_channel()).WillRepeatedly(ReturnNull());
EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull());
EXPECT_CALL(session_, GetTransportStats(_)).WillRepeatedly(Return(false));
EXPECT_CALL(session_, GetLocalCertificate(_, _)).WillRepeatedly(
Return(false));
@ -177,9 +167,6 @@ class RTCStatsCollectorTestHelper : public SetSessionDescriptionObserver {
}
rtc::ScopedFakeClock& fake_clock() { return fake_clock_; }
rtc::Thread* worker_thread() { return worker_thread_; }
rtc::Thread* network_thread() { return network_thread_; }
cricket::FakeMediaEngine* media_engine() { return media_engine_; }
MockWebRtcSession& session() { return session_; }
MockPeerConnection& pc() { return pc_; }
std::vector<rtc::scoped_refptr<DataChannel>>& data_channels() {
@ -197,7 +184,6 @@ class RTCStatsCollectorTestHelper : public SetSessionDescriptionObserver {
webrtc::RtcEventLogNullImpl event_log_;
rtc::Thread* const worker_thread_;
rtc::Thread* const network_thread_;
cricket::FakeMediaEngine* media_engine_;
std::unique_ptr<cricket::ChannelManager> channel_manager_;
std::unique_ptr<webrtc::MediaControllerInterface> media_controller_;
MockWebRtcSession session_;
@ -285,7 +271,7 @@ class FakeRTCStatsCollector : public RTCStatsCollector,
}
rtc::scoped_refptr<RTCStatsReport> signaling_report =
RTCStatsReport::Create(0);
RTCStatsReport::Create();
signaling_report->AddStats(std::unique_ptr<const RTCStats>(
new RTCTestStats("SignalingThreadStats", timestamp_us)));
AddPartialResults(signaling_report);
@ -298,8 +284,7 @@ class FakeRTCStatsCollector : public RTCStatsCollector,
++produced_on_worker_thread_;
}
rtc::scoped_refptr<RTCStatsReport> worker_report =
RTCStatsReport::Create(0);
rtc::scoped_refptr<RTCStatsReport> worker_report = RTCStatsReport::Create();
worker_report->AddStats(std::unique_ptr<const RTCStats>(
new RTCTestStats("WorkerThreadStats", timestamp_us)));
AddPartialResults(worker_report);
@ -313,7 +298,7 @@ class FakeRTCStatsCollector : public RTCStatsCollector,
}
rtc::scoped_refptr<RTCStatsReport> network_report =
RTCStatsReport::Create(0);
RTCStatsReport::Create();
network_report->AddStats(std::unique_ptr<const RTCStats>(
new RTCTestStats("NetworkThreadStats", timestamp_us)));
AddPartialResults(network_report);
@ -975,130 +960,6 @@ TEST_F(RTCStatsCollectorTest, CollectRTCPeerConnectionStats) {
}
}
TEST_F(RTCStatsCollectorTest, CollectRTCOutboundRTPStreamStats_Audio) {
MockVoiceMediaChannel* voice_media_channel = new MockVoiceMediaChannel();
cricket::VoiceChannel voice_channel(
test_->worker_thread(), test_->network_thread(), test_->media_engine(),
voice_media_channel, nullptr, "VoiceContentName", false);
cricket::VoiceMediaInfo voice_media_info;
voice_media_info.senders.push_back(cricket::VoiceSenderInfo());
voice_media_info.senders[0].local_stats.push_back(cricket::SsrcSenderInfo());
voice_media_info.senders[0].local_stats[0].ssrc = 1;
voice_media_info.senders[0].packets_sent = 2;
voice_media_info.senders[0].bytes_sent = 3;
voice_media_info.senders[0].rtt_ms = 4500.0;
EXPECT_CALL(*voice_media_channel, GetStats(_))
.WillOnce(DoAll(SetArgPointee<0>(voice_media_info), Return(true)));
SessionStats session_stats;
session_stats.proxy_to_transport["VoiceContentName"] = "TransportName";
session_stats.transport_stats["TransportName"].transport_name =
"TransportName";
// Make sure the associated |RTCTransportStats| is created.
cricket::TransportChannelStats channel_stats;
channel_stats.component = cricket::ICE_CANDIDATE_COMPONENT_RTP;
cricket::ConnectionInfo connection_info;
connection_info.local_candidate = *CreateFakeCandidate(
"42.42.42.42", 42, "protocol", cricket::LOCAL_PORT_TYPE, 42).get();
connection_info.remote_candidate = *CreateFakeCandidate(
"42.42.42.42", 42, "protocol", cricket::LOCAL_PORT_TYPE, 42).get();
channel_stats.connection_infos.push_back(connection_info);
session_stats.transport_stats["TransportName"].channel_stats.push_back(
channel_stats);
EXPECT_CALL(test_->session(), GetTransportStats(_))
.WillRepeatedly(DoAll(SetArgPointee<0>(session_stats), Return(true)));
EXPECT_CALL(test_->session(), voice_channel())
.WillRepeatedly(Return(&voice_channel));
rtc::scoped_refptr<const RTCStatsReport> report = GetStatsReport();
RTCOutboundRTPStreamStats expected_audio(
"RTCOutboundRTPAudioStream_1", report->timestamp_us());
expected_audio.ssrc = "1";
expected_audio.is_remote = false;
expected_audio.media_type = "audio";
expected_audio.transport_id = "RTCTransport_TransportName_" +
rtc::ToString<>(cricket::ICE_CANDIDATE_COMPONENT_RTP);
expected_audio.packets_sent = 2;
expected_audio.bytes_sent = 3;
expected_audio.round_trip_time = 4.5;
ASSERT(report->Get(expected_audio.id()));
const RTCOutboundRTPStreamStats& audio = report->Get(
expected_audio.id())->cast_to<RTCOutboundRTPStreamStats>();
EXPECT_EQ(audio, expected_audio);
EXPECT_TRUE(report->Get(*expected_audio.transport_id));
}
TEST_F(RTCStatsCollectorTest, CollectRTCOutboundRTPStreamStats_Video) {
MockVideoMediaChannel* video_media_channel = new MockVideoMediaChannel();
cricket::VideoChannel video_channel(
test_->worker_thread(), test_->network_thread(), video_media_channel,
nullptr, "VideoContentName", false);
cricket::VideoMediaInfo video_media_info;
video_media_info.senders.push_back(cricket::VideoSenderInfo());
video_media_info.senders[0].local_stats.push_back(cricket::SsrcSenderInfo());
video_media_info.senders[0].local_stats[0].ssrc = 1;
video_media_info.senders[0].firs_rcvd = 2;
video_media_info.senders[0].plis_rcvd = 3;
video_media_info.senders[0].nacks_rcvd = 4;
video_media_info.senders[0].packets_sent = 5;
video_media_info.senders[0].bytes_sent = 6;
video_media_info.senders[0].rtt_ms = 7500.0;
EXPECT_CALL(*video_media_channel, GetStats(_))
.WillOnce(DoAll(SetArgPointee<0>(video_media_info), Return(true)));
SessionStats session_stats;
session_stats.proxy_to_transport["VideoContentName"] = "TransportName";
session_stats.transport_stats["TransportName"].transport_name =
"TransportName";
// Make sure the associated |RTCTransportStats| is created.
cricket::TransportChannelStats channel_stats;
channel_stats.component = cricket::ICE_CANDIDATE_COMPONENT_RTP;
cricket::ConnectionInfo connection_info;
connection_info.local_candidate = *CreateFakeCandidate(
"42.42.42.42", 42, "protocol", cricket::LOCAL_PORT_TYPE, 42).get();
connection_info.remote_candidate = *CreateFakeCandidate(
"42.42.42.42", 42, "protocol", cricket::LOCAL_PORT_TYPE, 42).get();
channel_stats.connection_infos.push_back(connection_info);
session_stats.transport_stats["TransportName"].channel_stats.push_back(
channel_stats);
EXPECT_CALL(test_->session(), GetTransportStats(_))
.WillRepeatedly(DoAll(SetArgPointee<0>(session_stats), Return(true)));
EXPECT_CALL(test_->session(), video_channel())
.WillRepeatedly(Return(&video_channel));
rtc::scoped_refptr<const RTCStatsReport> report = GetStatsReport();
RTCOutboundRTPStreamStats expected_video(
"RTCOutboundRTPVideoStream_1", report->timestamp_us());
expected_video.ssrc = "1";
expected_video.is_remote = false;
expected_video.media_type = "video";
expected_video.transport_id = "RTCTransport_TransportName_" +
rtc::ToString<>(cricket::ICE_CANDIDATE_COMPONENT_RTP);
expected_video.fir_count = 2;
expected_video.pli_count = 3;
expected_video.nack_count = 4;
expected_video.packets_sent = 5;
expected_video.bytes_sent = 6;
expected_video.round_trip_time = 7.5;
ASSERT(report->Get(expected_video.id()));
const RTCOutboundRTPStreamStats& video = report->Get(
expected_video.id())->cast_to<RTCOutboundRTPStreamStats>();
EXPECT_EQ(video, expected_video);
EXPECT_TRUE(report->Get(*expected_video.transport_id));
}
TEST_F(RTCStatsCollectorTest, CollectRTCTransportStats) {
std::unique_ptr<cricket::Candidate> rtp_local_candidate = CreateFakeCandidate(
"42.42.42.42", 42, "protocol", cricket::LOCAL_PORT_TYPE, 42);

4
webrtc/api/stats/rtcstats.h
View File

@ -71,8 +71,8 @@ class RTCStats {
bool operator==(const RTCStats& other) const;
bool operator!=(const RTCStats& other) const;
// Creates a human readable string representation of the stats object, listing
// all of its members (names and values).
// Creates a human readable string representation of the report, listing all
// of its members (names and values).
std::string ToString() const;
// Downcasts the stats object to an |RTCStats| subclass |T|. DCHECKs that the

58
webrtc/api/stats/rtcstats_objects.h
View File

@ -82,7 +82,7 @@ class RTCDataChannelStats final : public RTCStats {
// https://w3c.github.io/webrtc-stats/#candidatepair-dict*
// TODO(hbos): Finish implementation. Tracking bug crbug.com/633550
class RTCIceCandidatePairStats final : public RTCStats {
class RTCIceCandidatePairStats : public RTCStats {
public:
WEBRTC_RTCSTATS_DECL();
@ -202,62 +202,6 @@ class RTCPeerConnectionStats final : public RTCStats {
RTCStatsMember<uint32_t> data_channels_closed;
};
// https://w3c.github.io/webrtc-stats/#streamstats-dict*
// TODO(hbos): Finish implementation. Tracking bug crbug.com/657854
class RTCRTPStreamStats : public RTCStats {
public:
WEBRTC_RTCSTATS_DECL();
RTCRTPStreamStats(const RTCRTPStreamStats& other);
~RTCRTPStreamStats() override;
RTCStatsMember<std::string> ssrc;
// TODO(hbos): When the remote case is supported |RTCStatsCollector| needs to
// set this. crbug.com/657855, 657856
RTCStatsMember<std::string> associate_stats_id;
// TODO(hbos): Remote case not supported by |RTCStatsCollector|.
// crbug.com/657855, 657856
RTCStatsMember<bool> is_remote; // = false
RTCStatsMember<std::string> media_type;
// TODO(hbos): Not collected by |RTCStatsCollector|. crbug.com/657854, 659137
RTCStatsMember<std::string> media_track_id;
RTCStatsMember<std::string> transport_id;
// TODO(hbos): Not collected by |RTCStatsCollector|. crbug.com/657854, 659117
RTCStatsMember<std::string> codec_id;
// FIR and PLI counts are only defined for |media_type == "video"|.
RTCStatsMember<uint32_t> fir_count;
RTCStatsMember<uint32_t> pli_count;
// TODO(hbos): NACK count should be collected by |RTCStatsCollector| for both
// audio and video but is only defined in the "video" case. crbug.com/657856
RTCStatsMember<uint32_t> nack_count;
// TODO(hbos): Not collected by |RTCStatsCollector|. crbug.com/657854
// SLI count is only defined for |media_type == "video"|.
RTCStatsMember<uint32_t> sli_count;
protected:
RTCRTPStreamStats(const std::string& id, int64_t timestamp_us);
RTCRTPStreamStats(std::string&& id, int64_t timestamp_us);
};
// https://w3c.github.io/webrtc-stats/#outboundrtpstats-dict*
// TODO(hbos): Finish implementation and support the remote case
// |is_remote = true|. Tracking bug crbug.com/657856
class RTCOutboundRTPStreamStats final : public RTCRTPStreamStats {
public:
WEBRTC_RTCSTATS_DECL();
RTCOutboundRTPStreamStats(const std::string& id, int64_t timestamp_us);
RTCOutboundRTPStreamStats(std::string&& id, int64_t timestamp_us);
RTCOutboundRTPStreamStats(const RTCOutboundRTPStreamStats& other);
~RTCOutboundRTPStreamStats() override;
RTCStatsMember<uint32_t> packets_sent;
RTCStatsMember<uint64_t> bytes_sent;
// TODO(hbos): Not collected by |RTCStatsCollector|. crbug.com/657856
RTCStatsMember<double> target_bitrate;
RTCStatsMember<double> round_trip_time;
};
// https://w3c.github.io/webrtc-stats/#transportstats-dict*
class RTCTransportStats final : public RTCStats {
public:

11
webrtc/api/stats/rtcstatsreport.h
View File

@ -36,7 +36,6 @@ class RTCStatsReport : public rtc::RefCountInterface {
ConstIterator& operator++();
ConstIterator& operator++(int);
const RTCStats& operator*() const;
const RTCStats* operator->() const;
bool operator==(const ConstIterator& other) const;
bool operator!=(const ConstIterator& other) const;
@ -50,12 +49,11 @@ class RTCStatsReport : public rtc::RefCountInterface {
StatsMap::const_iterator it_;
};
static rtc::scoped_refptr<RTCStatsReport> Create(uint64_t timestamp_us);
static rtc::scoped_refptr<RTCStatsReport> Create();
explicit RTCStatsReport(uint64_t timestamp_us);
RTCStatsReport();
RTCStatsReport(const RTCStatsReport& other) = delete;
uint64_t timestamp_us() const { return timestamp_us_; }
bool AddStats(std::unique_ptr<const RTCStats> stats);
const RTCStats* Get(const std::string& id) const;
size_t size() const { return stats_.size(); }
@ -79,16 +77,11 @@ class RTCStatsReport : public rtc::RefCountInterface {
return stats_of_type;
}
// Creates a human readable string representation of the report, listing all
// of its stats objects.
std::string ToString() const;
friend class rtc::RefCountedObject<RTCStatsReport>;
private:
~RTCStatsReport() override;
uint64_t timestamp_us_;
StatsMap stats_;
};

2
webrtc/stats/rtcstats.cc
View File

@ -10,8 +10,6 @@
#include "webrtc/api/stats/rtcstats.h"
#include <sstream>
#include "webrtc/base/stringencode.h"
namespace webrtc {

86
webrtc/stats/rtcstats_objects.cc
View File

@ -293,92 +293,6 @@ RTCPeerConnectionStats::RTCPeerConnectionStats(
RTCPeerConnectionStats::~RTCPeerConnectionStats() {
}
WEBRTC_RTCSTATS_IMPL(RTCRTPStreamStats, RTCStats, "rtp",
&ssrc,
&associate_stats_id,
&is_remote,
&media_type,
&media_track_id,
&transport_id,
&codec_id,
&fir_count,
&pli_count,
&nack_count,
&sli_count);
RTCRTPStreamStats::RTCRTPStreamStats(
const std::string& id, int64_t timestamp_us)
: RTCRTPStreamStats(std::string(id), timestamp_us) {
}
RTCRTPStreamStats::RTCRTPStreamStats(
std::string&& id, int64_t timestamp_us)
: RTCStats(std::move(id), timestamp_us),
ssrc("ssrc"),
associate_stats_id("associateStatsId"),
is_remote("isRemote", false),
media_type("mediaType"),
media_track_id("mediaTrackId"),
transport_id("transportId"),
codec_id("codecId"),
fir_count("firCount"),
pli_count("pliCount"),
nack_count("nackCount"),
sli_count("sliCount") {
}
RTCRTPStreamStats::RTCRTPStreamStats(
const RTCRTPStreamStats& other)
: RTCStats(other.id(), other.timestamp_us()),
ssrc(other.ssrc),
associate_stats_id(other.associate_stats_id),
is_remote(other.is_remote),
media_type(other.media_type),
media_track_id(other.media_track_id),
transport_id(other.transport_id),
codec_id(other.codec_id),
fir_count(other.fir_count),
pli_count(other.pli_count),
nack_count(other.nack_count),
sli_count(other.sli_count) {
}
RTCRTPStreamStats::~RTCRTPStreamStats() {
}
WEBRTC_RTCSTATS_IMPL(
RTCOutboundRTPStreamStats, RTCRTPStreamStats, "outbound-rtp",
&packets_sent,
&bytes_sent,
&target_bitrate,
&round_trip_time);
RTCOutboundRTPStreamStats::RTCOutboundRTPStreamStats(
const std::string& id, int64_t timestamp_us)
: RTCOutboundRTPStreamStats(std::string(id), timestamp_us) {
}
RTCOutboundRTPStreamStats::RTCOutboundRTPStreamStats(
std::string&& id, int64_t timestamp_us)
: RTCRTPStreamStats(std::move(id), timestamp_us),
packets_sent("packetsSent"),
bytes_sent("bytesSent"),
target_bitrate("targetBitrate"),
round_trip_time("roundTripTime") {
}
RTCOutboundRTPStreamStats::RTCOutboundRTPStreamStats(
const RTCOutboundRTPStreamStats& other)
: RTCRTPStreamStats(other),
packets_sent(other.packets_sent),
bytes_sent(other.bytes_sent),
target_bitrate(other.target_bitrate),
round_trip_time(other.round_trip_time) {
}
RTCOutboundRTPStreamStats::~RTCOutboundRTPStreamStats() {
}
WEBRTC_RTCSTATS_IMPL(RTCTransportStats, RTCStats, "transport",
&bytes_sent,
&bytes_received,

26
webrtc/stats/rtcstatsreport.cc
View File

@ -10,8 +10,6 @@
#include "webrtc/api/stats/rtcstatsreport.h"
#include <sstream>
namespace webrtc {
RTCStatsReport::ConstIterator::ConstIterator(
@ -42,10 +40,6 @@ const RTCStats& RTCStatsReport::ConstIterator::operator*() const {
return *it_->second.get();
}
const RTCStats* RTCStatsReport::ConstIterator::operator->() const {
return it_->second.get();
}
bool RTCStatsReport::ConstIterator::operator==(
const RTCStatsReport::ConstIterator& other) const {
return it_ == other.it_;
@ -56,14 +50,12 @@ bool RTCStatsReport::ConstIterator::operator!=(
return !(*this == other);
}
rtc::scoped_refptr<RTCStatsReport> RTCStatsReport::Create(
uint64_t timestamp_us) {
rtc::scoped_refptr<RTCStatsReport> RTCStatsReport::Create() {
return rtc::scoped_refptr<RTCStatsReport>(
new rtc::RefCountedObject<RTCStatsReport>(timestamp_us));
new rtc::RefCountedObject<RTCStatsReport>());
}
RTCStatsReport::RTCStatsReport(uint64_t timestamp_us)
: timestamp_us_(timestamp_us) {
RTCStatsReport::RTCStatsReport() {
}
RTCStatsReport::~RTCStatsReport() {
@ -100,16 +92,4 @@ RTCStatsReport::ConstIterator RTCStatsReport::end() const {
stats_.cend());
}
std::string RTCStatsReport::ToString() const {
std::ostringstream oss;
ConstIterator it = begin();
if (it != end()) {
oss << it->ToString();
for (++it; it != end(); ++it) {
oss << '\n' << it->ToString();
}
}
return oss.str();
}
} // namespace webrtc

12
webrtc/stats/rtcstatsreport_unittest.cc
View File

@ -59,8 +59,7 @@ WEBRTC_RTCSTATS_IMPL(RTCTestStats3, RTCStats, "test-stats-3",
&string);
TEST(RTCStatsReport, AddAndGetStats) {
rtc::scoped_refptr<RTCStatsReport> report = RTCStatsReport::Create(1337);
EXPECT_EQ(report->timestamp_us(), 1337u);
rtc::scoped_refptr<RTCStatsReport> report = RTCStatsReport::Create();
EXPECT_EQ(report->size(), static_cast<size_t>(0));
report->AddStats(std::unique_ptr<RTCStats>(new RTCTestStats1("a0", 1)));
report->AddStats(std::unique_ptr<RTCStats>(new RTCTestStats1("a1", 2)));
@ -93,8 +92,7 @@ TEST(RTCStatsReport, AddAndGetStats) {
}
TEST(RTCStatsReport, StatsOrder) {
rtc::scoped_refptr<RTCStatsReport> report = RTCStatsReport::Create(1337);
EXPECT_EQ(report->timestamp_us(), 1337u);
rtc::scoped_refptr<RTCStatsReport> report = RTCStatsReport::Create();
report->AddStats(std::unique_ptr<RTCStats>(new RTCTestStats1("C", 2)));
report->AddStats(std::unique_ptr<RTCStats>(new RTCTestStats1("D", 3)));
report->AddStats(std::unique_ptr<RTCStats>(new RTCTestStats2("B", 1)));
@ -111,13 +109,11 @@ TEST(RTCStatsReport, StatsOrder) {
}
TEST(RTCStatsReport, TakeMembersFrom) {
rtc::scoped_refptr<RTCStatsReport> a = RTCStatsReport::Create(1337);
EXPECT_EQ(a->timestamp_us(), 1337u);
rtc::scoped_refptr<RTCStatsReport> a = RTCStatsReport::Create();
a->AddStats(std::unique_ptr<RTCStats>(new RTCTestStats1("B", 1)));
a->AddStats(std::unique_ptr<RTCStats>(new RTCTestStats1("C", 2)));
a->AddStats(std::unique_ptr<RTCStats>(new RTCTestStats1("E", 4)));
rtc::scoped_refptr<RTCStatsReport> b = RTCStatsReport::Create(1338);
EXPECT_EQ(b->timestamp_us(), 1338u);
rtc::scoped_refptr<RTCStatsReport> b = RTCStatsReport::Create();
b->AddStats(std::unique_ptr<RTCStats>(new RTCTestStats1("A", 0)));
b->AddStats(std::unique_ptr<RTCStats>(new RTCTestStats1("D", 3)));
b->AddStats(std::unique_ptr<RTCStats>(new RTCTestStats1("F", 5)));