Remove traces from {send,receive}_statistics_proxy.cc

webrtc/video/send_statistics_proxy.cc

 /*
  *  Copyright (c) 2013 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/video/send_statistics_proxy.h"
 
 #include <algorithm>
 #include <cmath>
 #include <map>
 #include <vector>
 
 #include "webrtc/common_types.h"
 #include "webrtc/modules/video_coding/include/video_codec_interface.h"
 #include "webrtc/rtc_base/checks.h"
 #include "webrtc/rtc_base/logging.h"
-#include "webrtc/rtc_base/trace_event.h"
 #include "webrtc/system_wrappers/include/metrics.h"
 
 namespace webrtc {
 namespace {
 const float kEncodeTimeWeigthFactor = 0.5f;
 
 // Used by histograms. Values of entries should not be changed.
 enum HistogramCodecType {
   kVideoUnknown = 0,
   kVideoVp8 = 1,
@@ skipping 432 matching lines @@
         GetUmaPrefix(config.content_type), stats_, clock_));
     content_type_ = config.content_type;
   }
 }
 
 void SendStatisticsProxy::OnEncoderStatsUpdate(uint32_t framerate,
                                                uint32_t bitrate) {
   rtc::CritScope lock(&crit_);
   stats_.encode_frame_rate = framerate;
   stats_.media_bitrate_bps = bitrate;
-  TRACE_EVENT_INSTANT2("webrtc_stats", "WebRTC.Video.FrameRateSent",
-      "frame_rate", framerate, "ssrc", rtp_config_.ssrcs[0]);
 }
 
 void SendStatisticsProxy::OnEncodedFrameTimeMeasured(
     int encode_time_ms,
     const CpuOveruseMetrics& metrics) {
   rtc::CritScope lock(&crit_);
   uma_container_->encode_time_counter_.Add(encode_time_ms);
   encode_time_.Apply(1.0f, encode_time_ms);
   stats_.avg_encode_time_ms = round(encode_time_.filtered());
   stats_.encode_usage_percent = metrics.encode_usage_percent;
-  TRACE_EVENT_INSTANT2("webrtc_stats", "WebRTC.Video.EncodeTimeInMs",
-      "encode_time_ms", stats_.avg_encode_time_ms,
-      "ssrc", rtp_config_.ssrcs[0]);
-  TRACE_EVENT_INSTANT2("webrtc_stats", "WebRTC.Video.EncodeUsagePercent",
-      "encode_usage_percent", stats_.encode_usage_percent,
-      "ssrc", rtp_config_.ssrcs[0]);
 }
 
 void SendStatisticsProxy::OnSuspendChange(bool is_suspended) {
   int64_t now_ms = clock_->TimeInMilliseconds();
   rtc::CritScope lock(&crit_);
   stats_.suspended = is_suspended;
   if (is_suspended) {
     // Pause framerate (add min pause time since there may be frames/packets
     // that are not yet sent).
     const int64_t kMinMs = 500;
@@ skipping 196 matching lines @@
     uma_container_->max_sent_width_per_timestamp_ = 0;
     uma_container_->max_sent_height_per_timestamp_ = 0;
   }
   last_sent_frame_timestamp_ = encoded_image._timeStamp;
   uma_container_->max_sent_width_per_timestamp_ =
       std::max(uma_container_->max_sent_width_per_timestamp_,
                static_cast<int>(encoded_image._encodedWidth));
   uma_container_->max_sent_height_per_timestamp_ =
       std::max(uma_container_->max_sent_height_per_timestamp_,
                static_cast<int>(encoded_image._encodedHeight));
-
-  TRACE_EVENT_INSTANT2("webrtc_stats", "WebRTC.Video.SentWidthInPixels",
-      "frame_width", encoded_image._encodedWidth, "ssrc", ssrc);
-  TRACE_EVENT_INSTANT2("webrtc_stats", "WebRTC.Video.SentHeightInPixels",
-      "frame_height", encoded_image._encodedHeight, "ssrc", ssrc);
 }
 
 int SendStatisticsProxy::GetSendFrameRate() const {
   rtc::CritScope lock(&crit_);
   return stats_.encode_frame_rate;
 }
 
 void SendStatisticsProxy::OnIncomingFrame(int width, int height) {
   rtc::CritScope lock(&crit_);
   uma_container_->input_frame_rate_tracker_.AddSamples(1);
   uma_container_->input_fps_counter_.Add(1);
   uma_container_->input_width_counter_.Add(width);
   uma_container_->input_height_counter_.Add(height);
   if (cpu_downscales_ >= 0) {
     uma_container_->cpu_limited_frame_counter_.Add(
         stats_.cpu_limited_resolution);
   }
-  TRACE_EVENT_INSTANT2("webrtc_stats", "WebRTC.Video.InputFrameRate",
-      "frame_rate", round(
-          uma_container_->input_frame_rate_tracker_.ComputeRate()),
-      "ssrc", rtp_config_.ssrcs[0]);
 }
 
 void SendStatisticsProxy::SetAdaptationStats(
     const ViEEncoder::AdaptCounts& cpu_counts,
     const ViEEncoder::AdaptCounts& quality_counts) {
   rtc::CritScope lock(&crit_);
   SetAdaptTimer(cpu_counts, &uma_container_->cpu_adapt_timer_);
   SetAdaptTimer(quality_counts, &uma_container_->quality_adapt_timer_);
   UpdateAdaptationStats(cpu_counts, quality_counts);
 }
 
 void SendStatisticsProxy::OnCpuAdaptationChanged(
     const ViEEncoder::AdaptCounts& cpu_counts,
     const ViEEncoder::AdaptCounts& quality_counts) {
   rtc::CritScope lock(&crit_);
   ++stats_.number_of_cpu_adapt_changes;
   UpdateAdaptationStats(cpu_counts, quality_counts);
-  TRACE_EVENT_INSTANT0("webrtc_stats", "WebRTC.Video.CpuAdaptationChanges");
 }
 
 void SendStatisticsProxy::OnQualityAdaptationChanged(
     const ViEEncoder::AdaptCounts& cpu_counts,
     const ViEEncoder::AdaptCounts& quality_counts) {
   rtc::CritScope lock(&crit_);
   ++stats_.number_of_quality_adapt_changes;
   UpdateAdaptationStats(cpu_counts, quality_counts);
 }
 
@@ skipping 24 matching lines @@
     uint32_t ssrc,
     const RtcpPacketTypeCounter& packet_counter) {
   rtc::CritScope lock(&crit_);
   VideoSendStream::StreamStats* stats = GetStatsEntry(ssrc);
   if (!stats)
     return;
 
   stats->rtcp_packet_type_counts = packet_counter;
   if (uma_container_->first_rtcp_stats_time_ms_ == -1)
     uma_container_->first_rtcp_stats_time_ms_ = clock_->TimeInMilliseconds();
-
-  TRACE_EVENT_INSTANT2("webrtc_stats", "WebRTC.Video.FirPacketsReceived",
-      "fir_packets_received", packet_counter.fir_packets, "ssrc", ssrc);
-  TRACE_EVENT_INSTANT2("webrtc_stats", "WebRTC.Video.NackPacketsReceived",
-      "nack_packets_received", packet_counter.nack_packets, "ssrc", ssrc);
-  TRACE_EVENT_INSTANT2("webrtc_stats", "WebRTC.Video.PliPacketsReceived",
-      "pli_packets_received", packet_counter.pli_packets, "ssrc", ssrc);
 }
 
 void SendStatisticsProxy::StatisticsUpdated(const RtcpStatistics& statistics,
                                             uint32_t ssrc) {
   rtc::CritScope lock(&crit_);
   VideoSendStream::StreamStats* stats = GetStatsEntry(ssrc);
   if (!stats)
     return;
 
   stats->rtcp_stats = statistics;
   uma_container_->report_block_stats_.Store(statistics, 0, ssrc);
-
-  TRACE_EVENT_INSTANT2("webrtc_stats", "WebRTC.Video.SentPacketsLost",
-      "packets_lost", statistics.cumulative_lost, "ssrc", ssrc);
 }
 
 void SendStatisticsProxy::CNameChanged(const char* cname, uint32_t ssrc) {}
 
 void SendStatisticsProxy::DataCountersUpdated(
     const StreamDataCounters& counters,
     uint32_t ssrc) {
   rtc::CritScope lock(&crit_);
   VideoSendStream::StreamStats* stats = GetStatsEntry(ssrc);
   RTC_DCHECK(stats) << "DataCountersUpdated reported for unknown ssrc " << ssrc;
@@ skipping 18 matching lines @@
                                             ssrc);
   uma_container_->retransmit_byte_counter_.Set(
       counters.retransmitted.TotalBytes(), ssrc);
   uma_container_->fec_byte_counter_.Set(counters.fec.TotalBytes(), ssrc);
   if (stats->is_rtx) {
     uma_container_->rtx_byte_counter_.Set(counters.transmitted.TotalBytes(),
                                           ssrc);
   } else {
     uma_container_->media_byte_counter_.Set(counters.MediaPayloadBytes(), ssrc);
   }
-
-  TRACE_EVENT_INSTANT2("webrtc_stats", "WebRTC.Video.SentPackets",
-      "packets_sent", counters.transmitted.packets, "ssrc", ssrc);
 }
 
 void SendStatisticsProxy::Notify(uint32_t total_bitrate_bps,
                                  uint32_t retransmit_bitrate_bps,
                                  uint32_t ssrc) {
   rtc::CritScope lock(&crit_);
   VideoSendStream::StreamStats* stats = GetStatsEntry(ssrc);
   if (!stats)
     return;
 
@@ skipping 77 matching lines @@
 }
 
 int SendStatisticsProxy::BoolSampleCounter::Fraction(
     int64_t min_required_samples,
     float multiplier) const {
   if (num_samples < min_required_samples || num_samples == 0)
     return -1;
   return static_cast<int>((sum * multiplier / num_samples) + 0.5f);
 }
 }  // namespace webrtc