Filter out undesired initial -1 values.

webrtc/api/statscollector.cc

 /*
  *  Copyright 2012 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.
  */
 
@@ skipping 70 matching lines @@
     StatsReport* report = AddTrackReport(reports, track_id);
     RTC_DCHECK(report != nullptr);
     track_ids[track_id] = report;
   }
 }
 
 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);
+  if (info.rtt_ms >= 0) {
+    report->AddInt64(StatsReport::kStatsValueNameRtt, info.rtt_ms);
+  }
 }
 
 void ExtractCommonReceiveProperties(const cricket::MediaReceiverInfo& info,
                                     StatsReport* report) {
   report->AddString(StatsReport::kStatsValueNameCodecName, info.codec_name);
 }
 
 void SetAudioProcessingStats(StatsReport* report,
                              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);
+  if (aec_quality_min >= 0.0f) {
+    report->AddFloat(StatsReport::kStatsValueNameEchoCancellationQualityMin,
+                     aec_quality_min);
+  }
   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);
+  for (const auto& i : ints) {
+    if (i.value >= 0) {
+      report->AddInt(i.name, i.value);
+    }
+  }
+  // These can take on valid negative values.
+  report->AddInt(StatsReport::kStatsValueNameEchoReturnLoss, echo_return_loss);
+  report->AddInt(StatsReport::kStatsValueNameEchoReturnLossEnhancement,
+                 echo_return_loss_enhancement);
 }
 
 void ExtractStats(const cricket::VoiceReceiverInfo& info, StatsReport* report) {
   ExtractCommonReceiveProperties(info, report);
   const FloatForAdd floats[] = {
     { StatsReport::kStatsValueNameExpandRate, info.expand_rate },
     { StatsReport::kStatsValueNameSecondaryDecodedRate,
       info.secondary_decoded_rate },
     { StatsReport::kStatsValueNameSpeechExpandRate, info.speech_expand_rate },
     { StatsReport::kStatsValueNameAccelerateRate, info.accelerate_rate },
     { StatsReport::kStatsValueNamePreemptiveExpandRate,
       info.preemptive_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);
+  if (info.audio_level >= 0) {
+    report->AddInt(StatsReport::kStatsValueNameAudioOutputLevel,
+                   info.audio_level);
+  }
 
   report->AddInt64(StatsReport::kStatsValueNameBytesReceived,
                    info.bytes_rcvd);
-  report->AddInt64(StatsReport::kStatsValueNameCaptureStartNtpTimeMs,
-                   info.capture_start_ntp_time_ms);
+  if (info.capture_start_ntp_time_ms >= 0) {
+    report->AddInt64(StatsReport::kStatsValueNameCaptureStartNtpTimeMs,
+                     info.capture_start_ntp_time_ms);
+  }
   report->AddString(StatsReport::kStatsValueNameMediaType, "audio");
 }
 
 void ExtractStats(const cricket::VoiceSenderInfo& info, StatsReport* report) {
   ExtractCommonSendProperties(info, report);
 
   SetAudioProcessingStats(
       report, info.typing_noise_detected, info.echo_return_loss,
       info.echo_return_loss_enhancement, info.echo_delay_median_ms,
       info.aec_quality_min, info.echo_delay_std_ms);
 
   RTC_DCHECK_GE(info.audio_level, 0);
   const IntForAdd ints[] = {
     { StatsReport::kStatsValueNameAudioInputLevel, info.audio_level},
     { StatsReport::kStatsValueNameJitterReceived, info.jitter_ms },
     { StatsReport::kStatsValueNamePacketsLost, info.packets_lost },
     { StatsReport::kStatsValueNamePacketsSent, info.packets_sent },
   };
 
-  for (const auto& i : ints)
-    report->AddInt(i.name, i.value);
+  for (const auto& i : ints) {
+    if (i.value >= 0) {
+      report->AddInt(i.name, i.value);
+    }
+  }
   report->AddString(StatsReport::kStatsValueNameMediaType, "audio");
 }
 
 void ExtractStats(const cricket::VideoReceiverInfo& info, StatsReport* report) {
   ExtractCommonReceiveProperties(info, report);
   report->AddString(StatsReport::kStatsValueNameCodecImplementationName,
                     info.decoder_implementation_name);
   report->AddInt64(StatsReport::kStatsValueNameBytesReceived,
                    info.bytes_rcvd);
-  report->AddInt64(StatsReport::kStatsValueNameCaptureStartNtpTimeMs,
-                   info.capture_start_ntp_time_ms);
+  if (info.capture_start_ntp_time_ms >= 0) {
+    report->AddInt64(StatsReport::kStatsValueNameCaptureStartNtpTimeMs,
+                     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 },
@@ skipping 660 matching lines @@
   RTC_DCHECK(pc_->session()->signaling_thread()->IsCurrent());
 
   rtc::Thread::ScopedDisallowBlockingCalls no_blocking_calls;
 
   for (const auto& dc : pc_->sctp_data_channels()) {
     StatsReport::Id id(StatsReport::NewTypedIntId(
         StatsReport::kStatsReportTypeDataChannel, dc->id()));
     StatsReport* report = reports_.ReplaceOrAddNew(id);
     report->set_timestamp(stats_gathering_started_);
     report->AddString(StatsReport::kStatsValueNameLabel, dc->label());
-    report->AddInt(StatsReport::kStatsValueNameDataChannelId, dc->id());
+    // Filter out the initial id (-1).
+    if (dc->id() >= 0) {
+      report->AddInt(StatsReport::kStatsValueNameDataChannelId, dc->id());
+    }
     report->AddString(StatsReport::kStatsValueNameProtocol, dc->protocol());
     report->AddString(StatsReport::kStatsValueNameState,
                       DataChannelInterface::DataStateString(dc->state()));
   }
 }
 
 StatsReport* StatsCollector::GetReport(const StatsReport::StatsType& type,
                                        const std::string& id,
                                        StatsReport::Direction direction) {
   RTC_DCHECK(pc_->session()->signaling_thread()->IsCurrent());
@@ skipping 88 matching lines @@
     StatsReport* report = entry.second;
     report->set_timestamp(stats_gathering_started_);
   }
 }
 
 void StatsCollector::ClearUpdateStatsCacheForTest() {
   stats_gathering_started_ = 0;
 }
 
 }  // namespace webrtc