generic-library/webrtc
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Start using std::map for Values in the statscollector. This is in preparaton for more work which will cut down on the string copying work we do.

Browse Source 
Rename "AddValue" methods to AddXxx where Xxx is the type being added. Moving forward, we'll support those types natively without conversion to string.

Normalizing the extraction code to have fewer places that add the same stats and data driven additions to reports instead of multiple call sites.

BUG=2822
R=perkj@webrtc.org

Review URL: https://webrtc-codereview.appspot.com/47369004

Cr-Commit-Position: refs/heads/master@{#8597}
git-svn-id: http://webrtc.googlecode.com/svn/trunk@8597 4adac7df-926f-26a2-2b94-8c16560cd09d
This commit is contained in:
tommi@webrtc.org 2015-03-04 15:25:19 +00:00
parent 14665ff7d4
commit 92f4018d80
8 changed files with 262 additions and 336 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
talk/app/webrtc/java/jni/peerconnection_jni.cc
View File

@ -658,16 +658,16 @@ class StatsObserverWrapper : public StatsObserver {
jobjectArray ValuesToJava(JNIEnv* jni, const StatsReport::Values& values) { jobjectArray ValuesToJava(JNIEnv* jni, const StatsReport::Values& values) {
jobjectArray j_values = jni->NewObjectArray( jobjectArray j_values = jni->NewObjectArray(
values.size(), *j_value_class_, NULL); values.size(), *j_value_class_, NULL);
for (int i = 0; i < values.size(); ++i) { int i = 0;
for (const auto& it : values) {
ScopedLocalRefFrame local_ref_frame(jni); ScopedLocalRefFrame local_ref_frame(jni);
const auto& value = values[i];
// Should we use the '.name' enum value here instead of converting the // Should we use the '.name' enum value here instead of converting the
// name to a string? // name to a string?
jstring j_name = JavaStringFromStdString(jni, value->display_name()); jstring j_name = JavaStringFromStdString(jni, it.second->display_name());
jstring j_value = JavaStringFromStdString(jni, value->value); jstring j_value = JavaStringFromStdString(jni, it.second->ToString());
jobject j_element_value = jobject j_element_value =
jni->NewObject(*j_value_class_, j_value_ctor_, j_name, j_value); jni->NewObject(*j_value_class_, j_value_ctor_, j_name, j_value);
jni->SetObjectArrayElement(j_values, i, j_element_value); jni->SetObjectArrayElement(j_values, i++, j_element_value);
} }
return j_values; return j_values;
} }

6
talk/app/webrtc/objc/RTCStatsReport.mm
View File

@ -55,9 +55,9 @@
_timestamp = statsReport.timestamp(); _timestamp = statsReport.timestamp();
NSMutableArray* values = NSMutableArray* values =
[NSMutableArray arrayWithCapacity:statsReport.values().size()]; [NSMutableArray arrayWithCapacity:statsReport.values().size()];
for (const auto& v : statsReport.values()) { for (const auto& it : statsReport.values()) {
RTCPair* pair = [[RTCPair alloc] initWithKey:@(v->display_name()) RTCPair* pair = [[RTCPair alloc] initWithKey:@(it.second->display_name())
value:@(v->value.c_str())]; value:@(it.second->value.c_str())];
[values addObject:pair]; [values addObject:pair];
} }
_values = values; _values = values;

416
talk/app/webrtc/statscollector.cc
View File

@ -57,6 +57,16 @@ const char* STATSREPORT_ADAPTER_TYPE_WWAN = "wwan";
const char* STATSREPORT_ADAPTER_TYPE_VPN = "vpn"; const char* STATSREPORT_ADAPTER_TYPE_VPN = "vpn";
const char* STATSREPORT_ADAPTER_TYPE_LOOPBACK = "loopback"; const char* STATSREPORT_ADAPTER_TYPE_LOOPBACK = "loopback";
struct FloatForAdd {
const StatsReport::StatsValueName name;
const float& value;
};
struct IntForAdd {
const StatsReport::StatsValueName name;
const int value;
};
bool GetTransportIdFromProxy(const cricket::ProxyTransportMap& map, bool GetTransportIdFromProxy(const cricket::ProxyTransportMap& map,
const std::string& proxy, const std::string& proxy,
std::string* transport) { std::string* transport) {
@ -87,7 +97,7 @@ void AddTrackReport(StatsCollection* reports, const std::string& track_id) {
rtc::scoped_ptr<StatsReport::Id> id( rtc::scoped_ptr<StatsReport::Id> id(
StatsReport::NewTypedId(StatsReport::kStatsReportTypeTrack, track_id)); StatsReport::NewTypedId(StatsReport::kStatsReportTypeTrack, track_id));
StatsReport* report = reports->ReplaceOrAddNew(id.Pass()); StatsReport* report = reports->ReplaceOrAddNew(id.Pass());
report->AddValue(StatsReport::kStatsValueNameTrackId, track_id); report->AddString(StatsReport::kStatsValueNameTrackId, track_id);
} }
template <class TrackVector> template <class TrackVector>
@ -98,160 +108,155 @@ void CreateTrackReports(const TrackVector& tracks, StatsCollection* reports) {
} }
} }
void ExtractCommonSendProperties(const cricket::MediaSenderInfo& info,
StatsReport* report) {
report->AddString(StatsReport::kStatsValueNameCodecName, info.codec_name);
report->AddInt64(StatsReport::kStatsValueNameBytesSent, info.bytes_sent);
report->AddInt64(StatsReport::kStatsValueNameRtt, info.rtt_ms);
}
void SetAudioProcessingStats(StatsReport* report, int signal_level,
bool typing_noise_detected, int echo_return_loss,
int echo_return_loss_enhancement, int echo_delay_median_ms,
float aec_quality_min, int echo_delay_std_ms) {
report->AddBoolean(StatsReport::kStatsValueNameTypingNoiseState,
typing_noise_detected);
report->AddFloat(StatsReport::kStatsValueNameEchoCancellationQualityMin,
aec_quality_min);
// Don't overwrite the previous signal level if it's not available now.
if (signal_level >= 0)
report->AddInt(StatsReport::kStatsValueNameAudioInputLevel, signal_level);
const IntForAdd ints[] = {
{ StatsReport::kStatsValueNameEchoReturnLoss, echo_return_loss },
{ StatsReport::kStatsValueNameEchoReturnLossEnhancement,
echo_return_loss_enhancement },
{ StatsReport::kStatsValueNameEchoDelayMedian, echo_delay_median_ms },
{ StatsReport::kStatsValueNameEchoDelayStdDev, echo_delay_std_ms },
};
for (const auto& i : ints)
report->AddInt(i.name, i.value);
}
void ExtractStats(const cricket::VoiceReceiverInfo& info, StatsReport* report) { void ExtractStats(const cricket::VoiceReceiverInfo& info, StatsReport* report) {
report->AddValue(StatsReport::kStatsValueNameAudioOutputLevel, const FloatForAdd floats[] = {
info.audio_level); { StatsReport::kStatsValueNameExpandRate, info.expand_rate },
report->AddValue(StatsReport::kStatsValueNameBytesReceived, { StatsReport::kStatsValueNameSecondaryDecodedRate,
info.secondary_decoded_rate },
{ StatsReport::kStatsValueNameSpeechExpandRate, info.speech_expand_rate },
};
const IntForAdd ints[] = {
{ StatsReport::kStatsValueNameAudioOutputLevel, info.audio_level },
{ StatsReport::kStatsValueNameCurrentDelayMs, info.delay_estimate_ms },
{ StatsReport::kStatsValueNameDecodingCNG, info.decoding_cng },
{ StatsReport::kStatsValueNameDecodingCTN, info.decoding_calls_to_neteq },
{ StatsReport::kStatsValueNameDecodingCTSG,
info.decoding_calls_to_silence_generator },
{ StatsReport::kStatsValueNameDecodingNormal, info.decoding_normal },
{ StatsReport::kStatsValueNameDecodingPLC, info.decoding_plc },
{ StatsReport::kStatsValueNameDecodingPLCCNG, info.decoding_plc_cng },
{ StatsReport::kStatsValueNameJitterBufferMs, info.jitter_buffer_ms },
{ StatsReport::kStatsValueNameJitterReceived, info.jitter_ms },
{ StatsReport::kStatsValueNamePacketsLost, info.packets_lost },
{ StatsReport::kStatsValueNamePacketsReceived, info.packets_rcvd },
{ StatsReport::kStatsValueNamePreferredJitterBufferMs,
info.jitter_buffer_preferred_ms },
};
for (const auto& f : floats)
report->AddFloat(f.name, f.value);
for (const auto& i : ints)
report->AddInt(i.name, i.value);
report->AddInt64(StatsReport::kStatsValueNameBytesReceived,
info.bytes_rcvd); info.bytes_rcvd);
report->AddValue(StatsReport::kStatsValueNameJitterReceived, report->AddInt64(StatsReport::kStatsValueNameCaptureStartNtpTimeMs,
info.jitter_ms);
report->AddValue(StatsReport::kStatsValueNameJitterBufferMs,
info.jitter_buffer_ms);
report->AddValue(StatsReport::kStatsValueNamePreferredJitterBufferMs,
info.jitter_buffer_preferred_ms);
report->AddValue(StatsReport::kStatsValueNameCurrentDelayMs,
info.delay_estimate_ms);
report->AddValue(StatsReport::kStatsValueNameExpandRate,
rtc::ToString<float>(info.expand_rate));
report->AddValue(StatsReport::kStatsValueNameSpeechExpandRate,
rtc::ToString<float>(info.speech_expand_rate));
report->AddValue(StatsReport::kStatsValueNameSecondaryDecodedRate,
rtc::ToString<float>(info.secondary_decoded_rate));
report->AddValue(StatsReport::kStatsValueNamePacketsReceived,
info.packets_rcvd);
report->AddValue(StatsReport::kStatsValueNamePacketsLost,
info.packets_lost);
report->AddValue(StatsReport::kStatsValueNameDecodingCTSG,
info.decoding_calls_to_silence_generator);
report->AddValue(StatsReport::kStatsValueNameDecodingCTN,
info.decoding_calls_to_neteq);
report->AddValue(StatsReport::kStatsValueNameDecodingNormal,
info.decoding_normal);
report->AddValue(StatsReport::kStatsValueNameDecodingPLC,
info.decoding_plc);
report->AddValue(StatsReport::kStatsValueNameDecodingCNG,
info.decoding_cng);
report->AddValue(StatsReport::kStatsValueNameDecodingPLCCNG,
info.decoding_plc_cng);
report->AddValue(StatsReport::kStatsValueNameCaptureStartNtpTimeMs,
info.capture_start_ntp_time_ms); info.capture_start_ntp_time_ms);
report->AddValue(StatsReport::kStatsValueNameCodecName, info.codec_name);
report->AddString(StatsReport::kStatsValueNameCodecName, info.codec_name);
} }
void ExtractStats(const cricket::VoiceSenderInfo& info, StatsReport* report) { void ExtractStats(const cricket::VoiceSenderInfo& info, StatsReport* report) {
report->AddValue(StatsReport::kStatsValueNameAudioInputLevel, ExtractCommonSendProperties(info, report);
info.audio_level);
report->AddValue(StatsReport::kStatsValueNameBytesSent, SetAudioProcessingStats(report, info.audio_level, info.typing_noise_detected,
info.bytes_sent); info.echo_return_loss, info.echo_return_loss_enhancement,
report->AddValue(StatsReport::kStatsValueNamePacketsSent, info.echo_delay_median_ms, info.aec_quality_min, info.echo_delay_std_ms);
info.packets_sent);
report->AddValue(StatsReport::kStatsValueNamePacketsLost, const IntForAdd ints[] = {
info.packets_lost); { StatsReport::kStatsValueNameJitterReceived, info.jitter_ms },
report->AddValue(StatsReport::kStatsValueNameJitterReceived, { StatsReport::kStatsValueNamePacketsLost, info.packets_lost },
info.jitter_ms); { StatsReport::kStatsValueNamePacketsSent, info.packets_sent },
report->AddValue(StatsReport::kStatsValueNameRtt, info.rtt_ms); };
report->AddValue(StatsReport::kStatsValueNameEchoCancellationQualityMin,
rtc::ToString<float>(info.aec_quality_min)); for (const auto& i : ints)
report->AddValue(StatsReport::kStatsValueNameEchoDelayMedian, report->AddInt(i.name, i.value);
info.echo_delay_median_ms);
report->AddValue(StatsReport::kStatsValueNameEchoDelayStdDev,
info.echo_delay_std_ms);
report->AddValue(StatsReport::kStatsValueNameEchoReturnLoss,
info.echo_return_loss);
report->AddValue(StatsReport::kStatsValueNameEchoReturnLossEnhancement,
info.echo_return_loss_enhancement);
report->AddValue(StatsReport::kStatsValueNameCodecName, info.codec_name);
report->AddBoolean(StatsReport::kStatsValueNameTypingNoiseState,
info.typing_noise_detected);
} }
void ExtractStats(const cricket::VideoReceiverInfo& info, StatsReport* report) { void ExtractStats(const cricket::VideoReceiverInfo& info, StatsReport* report) {
report->AddValue(StatsReport::kStatsValueNameBytesReceived, report->AddInt64(StatsReport::kStatsValueNameBytesReceived,
info.bytes_rcvd); info.bytes_rcvd);
report->AddValue(StatsReport::kStatsValueNamePacketsReceived, report->AddInt64(StatsReport::kStatsValueNameCaptureStartNtpTimeMs,
info.packets_rcvd);
report->AddValue(StatsReport::kStatsValueNamePacketsLost,
info.packets_lost);
report->AddValue(StatsReport::kStatsValueNameFirsSent,
info.firs_sent);
report->AddValue(StatsReport::kStatsValueNamePlisSent,
info.plis_sent);
report->AddValue(StatsReport::kStatsValueNameNacksSent,
info.nacks_sent);
report->AddValue(StatsReport::kStatsValueNameFrameWidthReceived,
info.frame_width);
report->AddValue(StatsReport::kStatsValueNameFrameHeightReceived,
info.frame_height);
report->AddValue(StatsReport::kStatsValueNameFrameRateReceived,
info.framerate_rcvd);
report->AddValue(StatsReport::kStatsValueNameFrameRateDecoded,
info.framerate_decoded);
report->AddValue(StatsReport::kStatsValueNameFrameRateOutput,
info.framerate_output);
report->AddValue(StatsReport::kStatsValueNameDecodeMs,
info.decode_ms);
report->AddValue(StatsReport::kStatsValueNameMaxDecodeMs,
info.max_decode_ms);
report->AddValue(StatsReport::kStatsValueNameCurrentDelayMs,
info.current_delay_ms);
report->AddValue(StatsReport::kStatsValueNameTargetDelayMs,
info.target_delay_ms);
report->AddValue(StatsReport::kStatsValueNameJitterBufferMs,
info.jitter_buffer_ms);
report->AddValue(StatsReport::kStatsValueNameMinPlayoutDelayMs,
info.min_playout_delay_ms);
report->AddValue(StatsReport::kStatsValueNameRenderDelayMs,
info.render_delay_ms);
report->AddValue(StatsReport::kStatsValueNameCaptureStartNtpTimeMs,
info.capture_start_ntp_time_ms); info.capture_start_ntp_time_ms);
const IntForAdd ints[] = {
{ StatsReport::kStatsValueNameCurrentDelayMs, info.current_delay_ms },
{ StatsReport::kStatsValueNameDecodeMs, info.decode_ms },
{ StatsReport::kStatsValueNameFirsSent, info.firs_sent },
{ StatsReport::kStatsValueNameFrameHeightReceived, info.frame_height },
{ StatsReport::kStatsValueNameFrameRateDecoded, info.framerate_decoded },
{ StatsReport::kStatsValueNameFrameRateOutput, info.framerate_output },
{ StatsReport::kStatsValueNameFrameRateReceived, info.framerate_rcvd },
{ StatsReport::kStatsValueNameFrameWidthReceived, info.frame_width },
{ StatsReport::kStatsValueNameJitterBufferMs, info.jitter_buffer_ms },
{ StatsReport::kStatsValueNameMaxDecodeMs, info.max_decode_ms },
{ StatsReport::kStatsValueNameMinPlayoutDelayMs,
info.min_playout_delay_ms },
{ StatsReport::kStatsValueNameNacksSent, info.nacks_sent },
{ StatsReport::kStatsValueNamePacketsLost, info.packets_lost },
{ StatsReport::kStatsValueNamePacketsReceived, info.packets_rcvd },
{ StatsReport::kStatsValueNamePlisSent, info.plis_sent },
{ StatsReport::kStatsValueNameRenderDelayMs, info.render_delay_ms },
{ StatsReport::kStatsValueNameTargetDelayMs, info.target_delay_ms },
};
for (const auto& i : ints)
report->AddInt(i.name, i.value);
} }
void ExtractStats(const cricket::VideoSenderInfo& info, StatsReport* report) { void ExtractStats(const cricket::VideoSenderInfo& info, StatsReport* report) {
report->AddValue(StatsReport::kStatsValueNameBytesSent, ExtractCommonSendProperties(info, report);
info.bytes_sent);
report->AddValue(StatsReport::kStatsValueNamePacketsSent,
info.packets_sent);
report->AddValue(StatsReport::kStatsValueNamePacketsLost,
info.packets_lost);
report->AddValue(StatsReport::kStatsValueNameFirsReceived,
info.firs_rcvd);
report->AddValue(StatsReport::kStatsValueNamePlisReceived,
info.plis_rcvd);
report->AddValue(StatsReport::kStatsValueNameNacksReceived,
info.nacks_rcvd);
report->AddValue(StatsReport::kStatsValueNameFrameWidthInput,
info.input_frame_width);
report->AddValue(StatsReport::kStatsValueNameFrameHeightInput,
info.input_frame_height);
report->AddValue(StatsReport::kStatsValueNameFrameWidthSent,
info.send_frame_width);
report->AddValue(StatsReport::kStatsValueNameFrameHeightSent,
info.send_frame_height);
report->AddValue(StatsReport::kStatsValueNameFrameRateInput,
info.framerate_input);
report->AddValue(StatsReport::kStatsValueNameFrameRateSent,
info.framerate_sent);
report->AddValue(StatsReport::kStatsValueNameRtt, info.rtt_ms);
report->AddValue(StatsReport::kStatsValueNameCodecName, info.codec_name);
report->AddBoolean(StatsReport::kStatsValueNameCpuLimitedResolution,
(info.adapt_reason & 0x1) > 0);
report->AddBoolean(StatsReport::kStatsValueNameBandwidthLimitedResolution, report->AddBoolean(StatsReport::kStatsValueNameBandwidthLimitedResolution,
(info.adapt_reason & 0x2) > 0); (info.adapt_reason & 0x2) > 0);
report->AddBoolean(StatsReport::kStatsValueNameCpuLimitedResolution,
(info.adapt_reason & 0x1) > 0);
report->AddBoolean(StatsReport::kStatsValueNameViewLimitedResolution, report->AddBoolean(StatsReport::kStatsValueNameViewLimitedResolution,
(info.adapt_reason & 0x4) > 0); (info.adapt_reason & 0x4) > 0);
report->AddValue(StatsReport::kStatsValueNameAdaptationChanges,
info.adapt_changes); const IntForAdd ints[] = {
report->AddValue(StatsReport::kStatsValueNameAvgEncodeMs, info.avg_encode_ms); { StatsReport::kStatsValueNameAdaptationChanges, info.adapt_changes },
report->AddValue(StatsReport::kStatsValueNameCaptureJitterMs, { StatsReport::kStatsValueNameAvgEncodeMs, info.avg_encode_ms },
info.capture_jitter_ms); { StatsReport::kStatsValueNameCaptureJitterMs, info.capture_jitter_ms },
report->AddValue(StatsReport::kStatsValueNameCaptureQueueDelayMsPerS, { StatsReport::kStatsValueNameCaptureQueueDelayMsPerS,
info.capture_queue_delay_ms_per_s); info.capture_queue_delay_ms_per_s },
report->AddValue(StatsReport::kStatsValueNameEncodeUsagePercent, { StatsReport::kStatsValueNameEncodeUsagePercent,
info.encode_usage_percent); info.encode_usage_percent },
{ StatsReport::kStatsValueNameFirsReceived, info.firs_rcvd },
{ StatsReport::kStatsValueNameFrameHeightInput, info.input_frame_height },
{ StatsReport::kStatsValueNameFrameHeightSent, info.send_frame_height },
{ StatsReport::kStatsValueNameFrameRateInput, info.framerate_input },
{ StatsReport::kStatsValueNameFrameRateSent, info.framerate_sent },
{ StatsReport::kStatsValueNameFrameWidthInput, info.input_frame_width },
{ StatsReport::kStatsValueNameFrameWidthSent, info.send_frame_width },
{ StatsReport::kStatsValueNameNacksReceived, info.nacks_rcvd },
{ StatsReport::kStatsValueNamePacketsLost, info.packets_lost },
{ StatsReport::kStatsValueNamePacketsSent, info.packets_sent },
{ StatsReport::kStatsValueNamePlisReceived, info.plis_rcvd },
};
for (const auto& i : ints)
report->AddInt(i.name, i.value);
} }
void ExtractStats(const cricket::BandwidthEstimationInfo& info, void ExtractStats(const cricket::BandwidthEstimationInfo& info,
@ -266,19 +271,19 @@ void ExtractStats(const cricket::BandwidthEstimationInfo& info,
report->set_timestamp(stats_gathering_started); report->set_timestamp(stats_gathering_started);
} }
report->AddValue(StatsReport::kStatsValueNameAvailableSendBandwidth, report->AddInt(StatsReport::kStatsValueNameAvailableSendBandwidth,
info.available_send_bandwidth); info.available_send_bandwidth);
report->AddValue(StatsReport::kStatsValueNameAvailableReceiveBandwidth, report->AddInt(StatsReport::kStatsValueNameAvailableReceiveBandwidth,
info.available_recv_bandwidth); info.available_recv_bandwidth);
report->AddValue(StatsReport::kStatsValueNameTargetEncBitrate, report->AddInt(StatsReport::kStatsValueNameTargetEncBitrate,
info.target_enc_bitrate); info.target_enc_bitrate);
report->AddValue(StatsReport::kStatsValueNameActualEncBitrate, report->AddInt(StatsReport::kStatsValueNameActualEncBitrate,
info.actual_enc_bitrate); info.actual_enc_bitrate);
report->AddValue(StatsReport::kStatsValueNameRetransmitBitrate, report->AddInt(StatsReport::kStatsValueNameRetransmitBitrate,
info.retransmit_bitrate); info.retransmit_bitrate);
report->AddValue(StatsReport::kStatsValueNameTransmitBitrate, report->AddInt(StatsReport::kStatsValueNameTransmitBitrate,
info.transmit_bitrate); info.transmit_bitrate);
report->AddValue(StatsReport::kStatsValueNameBucketDelay, report->AddInt64(StatsReport::kStatsValueNameBucketDelay,
info.bucket_delay); info.bucket_delay);
} }
@ -404,7 +409,7 @@ void StatsCollector::AddLocalAudioTrack(AudioTrackInterface* audio_track,
StatsReport* report = reports_.Find(*id.get()); StatsReport* report = reports_.Find(*id.get());
if (!report) { if (!report) {
report = reports_.InsertNew(id.Pass()); report = reports_.InsertNew(id.Pass());
report->AddValue(StatsReport::kStatsValueNameTrackId, audio_track->id()); report->AddString(StatsReport::kStatsValueNameTrackId, audio_track->id());
} }
} }
@ -525,15 +530,14 @@ StatsReport* StatsCollector::PrepareReport(
report->ResetValues(); report->ResetValues();
} }
ASSERT(report->values().empty()); ASSERT(report->empty());
// FYI - for remote reports, the timestamp will be overwritten later. // FYI - for remote reports, the timestamp will be overwritten later.
report->set_timestamp(stats_gathering_started_); report->set_timestamp(stats_gathering_started_);
report->AddValue(StatsReport::kStatsValueNameSsrc, ssrc_id); report->AddString(StatsReport::kStatsValueNameSsrc, ssrc_id);
report->AddValue(StatsReport::kStatsValueNameTrackId, track_id); report->AddString(StatsReport::kStatsValueNameTrackId, track_id);
// Add the mapping of SSRC to transport. // Add the mapping of SSRC to transport.
report->AddValue(StatsReport::kStatsValueNameTransportId, report->AddString(StatsReport::kStatsValueNameTransportId, transport_id);
transport_id);
return report; return report;
} }
@ -572,12 +576,12 @@ std::string StatsCollector::AddOneCertificateReport(
StatsReport::kStatsReportTypeCertificate, fingerprint)); StatsReport::kStatsReportTypeCertificate, fingerprint));
StatsReport* report = reports_.ReplaceOrAddNew(id.Pass()); StatsReport* report = reports_.ReplaceOrAddNew(id.Pass());
report->set_timestamp(stats_gathering_started_); report->set_timestamp(stats_gathering_started_);
report->AddValue(StatsReport::kStatsValueNameFingerprint, fingerprint); report->AddString(StatsReport::kStatsValueNameFingerprint, fingerprint);
report->AddValue(StatsReport::kStatsValueNameFingerprintAlgorithm, report->AddString(StatsReport::kStatsValueNameFingerprintAlgorithm,
digest_algorithm); digest_algorithm);
report->AddValue(StatsReport::kStatsValueNameDer, der_base64); report->AddString(StatsReport::kStatsValueNameDer, der_base64);
if (!issuer_id.empty()) if (!issuer_id.empty())
report->AddValue(StatsReport::kStatsValueNameIssuerId, issuer_id); report->AddString(StatsReport::kStatsValueNameIssuerId, issuer_id);
// TODO(tommi): Can we avoid this? // TODO(tommi): Can we avoid this?
return report->id().ToString(); return report->id().ToString();
} }
@ -618,18 +622,18 @@ std::string StatsCollector::AddCandidateReport(
report = reports_.InsertNew(id.Pass()); report = reports_.InsertNew(id.Pass());
report->set_timestamp(stats_gathering_started_); report->set_timestamp(stats_gathering_started_);
if (local) { if (local) {
report->AddValue(StatsReport::kStatsValueNameCandidateNetworkType, report->AddString(StatsReport::kStatsValueNameCandidateNetworkType,
AdapterTypeToStatsType(candidate.network_type())); AdapterTypeToStatsType(candidate.network_type()));
} }
report->AddValue(StatsReport::kStatsValueNameCandidateIPAddress, report->AddString(StatsReport::kStatsValueNameCandidateIPAddress,
candidate.address().ipaddr().ToString()); candidate.address().ipaddr().ToString());
report->AddValue(StatsReport::kStatsValueNameCandidatePortNumber, report->AddString(StatsReport::kStatsValueNameCandidatePortNumber,
candidate.address().PortAsString()); candidate.address().PortAsString());
report->AddValue(StatsReport::kStatsValueNameCandidatePriority, report->AddInt(StatsReport::kStatsValueNameCandidatePriority,
candidate.priority()); candidate.priority());
report->AddValue(StatsReport::kStatsValueNameCandidateType, report->AddString(StatsReport::kStatsValueNameCandidateType,
IceCandidateTypeToStatsType(candidate.type())); IceCandidateTypeToStatsType(candidate.type()));
report->AddValue(StatsReport::kStatsValueNameCandidateTransportType, report->AddString(StatsReport::kStatsValueNameCandidateTransportType,
candidate.protocol()); candidate.protocol());
} }
@ -690,27 +694,27 @@ void StatsCollector::ExtractSessionInfo() {
channel_iter->component)); channel_iter->component));
StatsReport* channel_report = reports_.ReplaceOrAddNew(id.Pass()); StatsReport* channel_report = reports_.ReplaceOrAddNew(id.Pass());
channel_report->set_timestamp(stats_gathering_started_); channel_report->set_timestamp(stats_gathering_started_);
channel_report->AddValue(StatsReport::kStatsValueNameComponent, channel_report->AddInt(StatsReport::kStatsValueNameComponent,
channel_iter->component); channel_iter->component);
if (!local_cert_report_id.empty()) { if (!local_cert_report_id.empty()) {
channel_report->AddValue( channel_report->AddString(
StatsReport::kStatsValueNameLocalCertificateId, StatsReport::kStatsValueNameLocalCertificateId,
local_cert_report_id); local_cert_report_id);
} }
if (!remote_cert_report_id.empty()) { if (!remote_cert_report_id.empty()) {
channel_report->AddValue( channel_report->AddString(
StatsReport::kStatsValueNameRemoteCertificateId, StatsReport::kStatsValueNameRemoteCertificateId,
remote_cert_report_id); remote_cert_report_id);
} }
const std::string& srtp_cipher = channel_iter->srtp_cipher; const std::string& srtp_cipher = channel_iter->srtp_cipher;
if (!srtp_cipher.empty()) { if (!srtp_cipher.empty()) {
channel_report->AddValue( channel_report->AddString(
StatsReport::kStatsValueNameSrtpCipher, StatsReport::kStatsValueNameSrtpCipher,
srtp_cipher); srtp_cipher);
} }
const std::string& ssl_cipher = channel_iter->ssl_cipher; const std::string& ssl_cipher = channel_iter->ssl_cipher;
if (!ssl_cipher.empty()) { if (!ssl_cipher.empty()) {
channel_report->AddValue( channel_report->AddString(
StatsReport::kStatsValueNameDtlsCipher, StatsReport::kStatsValueNameDtlsCipher,
ssl_cipher); ssl_cipher);
} }
@ -724,43 +728,43 @@ void StatsCollector::ExtractSessionInfo() {
report->set_timestamp(stats_gathering_started_); report->set_timestamp(stats_gathering_started_);
// Link from connection to its containing channel. // Link from connection to its containing channel.
// TODO(tommi): Any way to avoid ToString here? // TODO(tommi): Any way to avoid ToString here?
report->AddValue(StatsReport::kStatsValueNameChannelId, report->AddString(StatsReport::kStatsValueNameChannelId,
channel_report->id().ToString()); channel_report->id().ToString());
const cricket::ConnectionInfo& info = const cricket::ConnectionInfo& info =
channel_iter->connection_infos[i]; channel_iter->connection_infos[i];
report->AddValue(StatsReport::kStatsValueNameBytesSent, report->AddInt64(StatsReport::kStatsValueNameBytesSent,
info.sent_total_bytes); info.sent_total_bytes);
report->AddValue(StatsReport::kStatsValueNameSendPacketsDiscarded, report->AddInt64(StatsReport::kStatsValueNameSendPacketsDiscarded,
info.sent_discarded_packets); info.sent_discarded_packets);
report->AddValue(StatsReport::kStatsValueNamePacketsSent, report->AddInt64(StatsReport::kStatsValueNamePacketsSent,
info.sent_total_packets); info.sent_total_packets);
report->AddValue(StatsReport::kStatsValueNameBytesReceived, report->AddInt64(StatsReport::kStatsValueNameBytesReceived,
info.recv_total_bytes); info.recv_total_bytes);
report->AddBoolean(StatsReport::kStatsValueNameWritable, report->AddBoolean(StatsReport::kStatsValueNameWritable,
info.writable); info.writable);
report->AddBoolean(StatsReport::kStatsValueNameReadable, report->AddBoolean(StatsReport::kStatsValueNameReadable,
info.readable); info.readable);
report->AddValue(StatsReport::kStatsValueNameLocalCandidateId, report->AddString(StatsReport::kStatsValueNameLocalCandidateId,
AddCandidateReport(info.local_candidate, true)); AddCandidateReport(info.local_candidate, true));
report->AddValue( report->AddString(
StatsReport::kStatsValueNameRemoteCandidateId, StatsReport::kStatsValueNameRemoteCandidateId,
AddCandidateReport(info.remote_candidate, false)); AddCandidateReport(info.remote_candidate, false));
report->AddValue(StatsReport::kStatsValueNameLocalAddress, report->AddString(StatsReport::kStatsValueNameLocalAddress,
info.local_candidate.address().ToString()); info.local_candidate.address().ToString());
report->AddValue(StatsReport::kStatsValueNameRemoteAddress, report->AddString(StatsReport::kStatsValueNameRemoteAddress,
info.remote_candidate.address().ToString()); info.remote_candidate.address().ToString());
report->AddValue(StatsReport::kStatsValueNameRtt, info.rtt); report->AddInt64(StatsReport::kStatsValueNameRtt, info.rtt);
report->AddValue(StatsReport::kStatsValueNameTransportType, report->AddString(StatsReport::kStatsValueNameTransportType,
info.local_candidate.protocol()); info.local_candidate.protocol());
report->AddValue(StatsReport::kStatsValueNameLocalCandidateType, report->AddString(StatsReport::kStatsValueNameLocalCandidateType,
info.local_candidate.type()); info.local_candidate.type());
report->AddValue(StatsReport::kStatsValueNameRemoteCandidateType, report->AddString(StatsReport::kStatsValueNameRemoteCandidateType,
info.remote_candidate.type()); info.remote_candidate.type());
report->AddBoolean(StatsReport::kStatsValueNameActiveConnection, report->AddBoolean(StatsReport::kStatsValueNameActiveConnection,
info.best_connection); info.best_connection);
if (info.best_connection) { if (info.best_connection) {
channel_report->AddValue( channel_report->AddString(
StatsReport::kStatsValueNameSelectedCandidatePairId, StatsReport::kStatsValueNameSelectedCandidatePairId,
report->id().ToString()); report->id().ToString());
} }
@ -841,10 +845,10 @@ void StatsCollector::ExtractDataInfo() {
StatsReport::kStatsReportTypeDataChannel, dc->id())); StatsReport::kStatsReportTypeDataChannel, dc->id()));
StatsReport* report = reports_.ReplaceOrAddNew(id.Pass()); StatsReport* report = reports_.ReplaceOrAddNew(id.Pass());
report->set_timestamp(stats_gathering_started_); report->set_timestamp(stats_gathering_started_);
report->AddValue(StatsReport::kStatsValueNameLabel, dc->label()); report->AddString(StatsReport::kStatsValueNameLabel, dc->label());
report->AddValue(StatsReport::kStatsValueNameDataChannelId, dc->id()); report->AddInt(StatsReport::kStatsValueNameDataChannelId, dc->id());
report->AddValue(StatsReport::kStatsValueNameProtocol, dc->protocol()); report->AddString(StatsReport::kStatsValueNameProtocol, dc->protocol());
report->AddValue(StatsReport::kStatsValueNameState, report->AddString(StatsReport::kStatsValueNameState,
DataChannelInterface::DataStateString(dc->state())); DataChannelInterface::DataStateString(dc->state()));
} }
} }
@ -858,23 +862,6 @@ StatsReport* StatsCollector::GetReport(const StatsReport::StatsType& type,
return reports_.Find(StatsReport::NewIdWithDirection(type, id, direction)); return reports_.Find(StatsReport::NewIdWithDirection(type, id, direction));
} }
StatsReport* StatsCollector::GetOrCreateReport(
const StatsReport::StatsType& type,
const std::string& id,
StatsReport::Direction direction) {
ASSERT(session_->signaling_thread()->IsCurrent());
ASSERT(type == StatsReport::kStatsReportTypeSsrc ||
type == StatsReport::kStatsReportTypeRemoteSsrc);
StatsReport* report = GetReport(type, id, direction);
if (report == NULL) {
rtc::scoped_ptr<StatsReport::Id> report_id(
StatsReport::NewIdWithDirection(type, id, direction));
report = reports_.InsertNew(report_id.Pass());
}
return report;
}
void StatsCollector::UpdateStatsFromExistingLocalAudioTracks() { void StatsCollector::UpdateStatsFromExistingLocalAudioTracks() {
ASSERT(session_->signaling_thread()->IsCurrent()); ASSERT(session_->signaling_thread()->IsCurrent());
// Loop through the existing local audio tracks. // Loop through the existing local audio tracks.
@ -882,7 +869,7 @@ void StatsCollector::UpdateStatsFromExistingLocalAudioTracks() {
it != local_audio_tracks_.end(); ++it) { it != local_audio_tracks_.end(); ++it) {
AudioTrackInterface* track = it->first; AudioTrackInterface* track = it->first;
uint32 ssrc = it->second; uint32 ssrc = it->second;
std::string ssrc_id = rtc::ToString<uint32>(ssrc); const std::string ssrc_id = rtc::ToString<uint32>(ssrc);
StatsReport* report = GetReport(StatsReport::kStatsReportTypeSsrc, StatsReport* report = GetReport(StatsReport::kStatsReportTypeSsrc,
ssrc_id, ssrc_id,
StatsReport::kSend); StatsReport::kSend);
@ -907,35 +894,22 @@ void StatsCollector::UpdateReportFromAudioTrack(AudioTrackInterface* track,
StatsReport* report) { StatsReport* report) {
ASSERT(session_->signaling_thread()->IsCurrent()); ASSERT(session_->signaling_thread()->IsCurrent());
ASSERT(track != NULL); ASSERT(track != NULL);
if (report == NULL)
return;
int signal_level = 0; int signal_level = 0;
if (track->GetSignalLevel(&signal_level)) { if (!track->GetSignalLevel(&signal_level))
report->ReplaceValue(StatsReport::kStatsValueNameAudioInputLevel, signal_level = -1;
rtc::ToString<int>(signal_level));
}
rtc::scoped_refptr<AudioProcessorInterface> audio_processor( rtc::scoped_refptr<AudioProcessorInterface> audio_processor(
track->GetAudioProcessor()); track->GetAudioProcessor());
if (audio_processor.get() == NULL)
return;
AudioProcessorInterface::AudioProcessorStats stats; AudioProcessorInterface::AudioProcessorStats stats;
if (audio_processor.get())
audio_processor->GetStats(&stats); audio_processor->GetStats(&stats);
report->ReplaceValue(StatsReport::kStatsValueNameTypingNoiseState,
stats.typing_noise_detected ? "true" : "false"); SetAudioProcessingStats(report, signal_level, stats.typing_noise_detected,
report->ReplaceValue(StatsReport::kStatsValueNameEchoReturnLoss, stats.echo_return_loss, stats.echo_return_loss_enhancement,
rtc::ToString<int>(stats.echo_return_loss)); stats.echo_delay_median_ms, stats.aec_quality_min,
report->ReplaceValue( stats.echo_delay_std_ms);
StatsReport::kStatsValueNameEchoReturnLossEnhancement,
rtc::ToString<int>(stats.echo_return_loss_enhancement));
report->ReplaceValue(StatsReport::kStatsValueNameEchoDelayMedian,
rtc::ToString<int>(stats.echo_delay_median_ms));
report->ReplaceValue(StatsReport::kStatsValueNameEchoCancellationQualityMin,
rtc::ToString<float>(stats.aec_quality_min));
report->ReplaceValue(StatsReport::kStatsValueNameEchoDelayStdDev,
rtc::ToString<int>(stats.echo_delay_std_ms));
} }
bool StatsCollector::GetTrackIdBySsrc(uint32 ssrc, std::string* track_id, bool StatsCollector::GetTrackIdBySsrc(uint32 ssrc, std::string* track_id,

3
talk/app/webrtc/statscollector.h
View File

@ -120,9 +120,6 @@ class StatsCollector {
void ExtractVoiceInfo(); void ExtractVoiceInfo();
void ExtractVideoInfo(PeerConnectionInterface::StatsOutputLevel level); void ExtractVideoInfo(PeerConnectionInterface::StatsOutputLevel level);
void BuildSsrcToTransportId(); void BuildSsrcToTransportId();
webrtc::StatsReport* GetOrCreateReport(const StatsReport::StatsType& type,
const std::string& id,
StatsReport::Direction direction);
webrtc::StatsReport* GetReport(const StatsReport::StatsType& type, webrtc::StatsReport* GetReport(const StatsReport::StatsType& type,
const std::string& id, const std::string& id,
StatsReport::Direction direction); StatsReport::Direction direction);

11
talk/app/webrtc/statscollector_unittest.cc
View File

@ -146,17 +146,14 @@ class FakeAudioTrack
rtc::scoped_refptr<FakeAudioProcessor> processor_; rtc::scoped_refptr<FakeAudioProcessor> processor_;
}; };
// TODO(tommi): Use FindValue().
bool GetValue(const StatsReport* report, bool GetValue(const StatsReport* report,
StatsReport::StatsValueName name, StatsReport::StatsValueName name,
std::string* value) { std::string* value) {
for (const auto& v : report->values()) { const StatsReport::Value* v = report->FindValue(name);
if (v->name == name) { if (!v)
*value = v->value;
return true;
}
}
return false; return false;
*value = v->ToString();
return true;
} }
std::string ExtractStatsValue(const StatsReport::StatsType& type, std::string ExtractStatsValue(const StatsReport::StatsType& type,

62
talk/app/webrtc/statstypes.cc
View File

@ -497,63 +497,26 @@ const char* StatsReport::TypeToString() const {
return InternalTypeToString(id_->type()); return InternalTypeToString(id_->type());
} }
void StatsReport::AddValue(StatsReport::StatsValueName name, void StatsReport::AddString(StatsReport::StatsValueName name,
const std::string& value) { const std::string& value) {
values_.push_back(ValuePtr(new Value(name, value))); values_[name] = ValuePtr(new Value(name, value));
} }
void StatsReport::AddValue(StatsReport::StatsValueName name, int64 value) { void StatsReport::AddInt64(StatsReport::StatsValueName name, int64 value) {
AddValue(name, rtc::ToString<int64>(value)); AddString(name, rtc::ToString<int64>(value));
} }
// TODO(tommi): Change the way we store vector values. void StatsReport::AddInt(StatsReport::StatsValueName name, int value) {
template <typename T> AddString(name, rtc::ToString<int>(value));
void StatsReport::AddValue(StatsReport::StatsValueName name,
const std::vector<T>& value) {
std::ostringstream oss;
oss << "[";
for (size_t i = 0; i < value.size(); ++i) {
oss << rtc::ToString<T>(value[i]);
if (i != value.size() - 1)
oss << ", ";
}
oss << "]";
AddValue(name, oss.str());
} }
// Implementation specializations for the variants of AddValue that we use. void StatsReport::AddFloat(StatsReport::StatsValueName name, float value) {
// TODO(tommi): Converting these ints to strings and copying strings, is not AddString(name, rtc::ToString<float>(value));
// very efficient. Figure out a way to reduce the string churn. }
template
void StatsReport::AddValue<std::string>(
StatsReport::StatsValueName, const std::vector<std::string>&);
template
void StatsReport::AddValue<int>(
StatsReport::StatsValueName, const std::vector<int>&);
template
void StatsReport::AddValue<int64_t>(
StatsReport::StatsValueName, const std::vector<int64_t>&);
void StatsReport::AddBoolean(StatsReport::StatsValueName name, bool value) { void StatsReport::AddBoolean(StatsReport::StatsValueName name, bool value) {
// TODO(tommi): Store bools as bool. // TODO(tommi): Store bools as bool.
AddValue(name, value ? "true" : "false"); AddString(name, value ? "true" : "false");
}
void StatsReport::ReplaceValue(StatsReport::StatsValueName name,
const std::string& value) {
Values::iterator it = std::find_if(values_.begin(), values_.end(),
[&name](const ValuePtr& v)->bool { return v->name == name; });
// Values are const once added since they may be used outside of the stats
// collection. So we remove it from values_ when replacing and add a new one.
if (it != values_.end()) {
if ((*it)->value == value)
return;
values_.erase(it);
}
AddValue(name, value);
} }
void StatsReport::ResetValues() { void StatsReport::ResetValues() {
@ -561,9 +524,8 @@ void StatsReport::ResetValues() {
} }
const StatsReport::Value* StatsReport::FindValue(StatsValueName name) const { const StatsReport::Value* StatsReport::FindValue(StatsValueName name) const {
Values::const_iterator it = std::find_if(values_.begin(), values_.end(), Values::const_iterator it = values_.find(name);
[&name](const ValuePtr& v)->bool { return v->name == name; }); return it == values_.end() ? nullptr : it->second.get();
return it == values_.end() ? nullptr : (*it).get();
} }
StatsCollection::StatsCollection() { StatsCollection::StatsCollection() {

17
talk/app/webrtc/statstypes.h
View File

@ -33,8 +33,8 @@
#include <algorithm> #include <algorithm>
#include <list> #include <list>
#include <map>
#include <string> #include <string>
#include <vector>
#include "webrtc/base/basictypes.h" #include "webrtc/base/basictypes.h"
#include "webrtc/base/linked_ptr.h" #include "webrtc/base/linked_ptr.h"
@ -241,7 +241,7 @@ class StatsReport {
// Returns the string representation of |name|. // Returns the string representation of |name|.
const char* display_name() const; const char* display_name() const;
const std::string& ToString() const; const std::string& ToString() const;
// TODO(tommi): Move |name| and |display_name| out of the Value struct.
const StatsValueName name; const StatsValueName name;
// TODO(tommi): Support more value types than string. // TODO(tommi): Support more value types than string.
const std::string value; const std::string value;
@ -251,7 +251,7 @@ class StatsReport {
}; };
typedef rtc::linked_ptr<Value> ValuePtr; typedef rtc::linked_ptr<Value> ValuePtr;
typedef std::vector<ValuePtr> Values; typedef std::map<StatsValueName, ValuePtr> Values;
// Ownership of |id| is passed to |this|. // Ownership of |id| is passed to |this|.
explicit StatsReport(rtc::scoped_ptr<Id> id); explicit StatsReport(rtc::scoped_ptr<Id> id);
@ -272,18 +272,17 @@ class StatsReport {
StatsType type() const { return id_->type(); } StatsType type() const { return id_->type(); }
double timestamp() const { return timestamp_; } double timestamp() const { return timestamp_; }
void set_timestamp(double t) { timestamp_ = t; } void set_timestamp(double t) { timestamp_ = t; }
bool empty() const { return values_.empty(); }
const Values& values() const { return values_; } const Values& values() const { return values_; }
const char* TypeToString() const; const char* TypeToString() const;
void AddValue(StatsValueName name, const std::string& value); void AddString(StatsValueName name, const std::string& value);
void AddValue(StatsValueName name, int64 value); void AddInt64(StatsValueName name, int64 value);
template <typename T> void AddInt(StatsValueName name, int value);
void AddValue(StatsValueName name, const std::vector<T>& value); void AddFloat(StatsValueName name, float value);
void AddBoolean(StatsValueName name, bool value); void AddBoolean(StatsValueName name, bool value);
void ReplaceValue(StatsValueName name, const std::string& value);
void ResetValues(); void ResetValues();
const Value* FindValue(StatsValueName name) const; const Value* FindValue(StatsValueName name) const;

23
talk/app/webrtc/test/mockpeerconnectionobservers.h
View File

@ -189,24 +189,21 @@ class MockStatsObserver : public webrtc::StatsObserver {
bool GetIntValue(const StatsReport* report, bool GetIntValue(const StatsReport* report,
StatsReport::StatsValueName name, StatsReport::StatsValueName name,
int* value) { int* value) {
for (const auto& v : report->values()) { const StatsReport::Value* v = report->FindValue(name);
if (v->name == name) { if (v) {
*value = rtc::FromString<int>(v->value); // TODO(tommi): We should really just be using an int here :-/
return true; *value = rtc::FromString<int>(v->ToString());
} }
return v != nullptr;
} }
return false;
}
bool GetStringValue(const StatsReport* report, bool GetStringValue(const StatsReport* report,
StatsReport::StatsValueName name, StatsReport::StatsValueName name,
std::string* value) { std::string* value) {
for (const auto& v : report->values()) { const StatsReport::Value* v = report->FindValue(name);
if (v->name == name) { if (v)
*value = v->value; *value = v->ToString();
return true; return v != nullptr;
}
}
return false;
} }
bool called_; bool called_;