Set webrtc_rtp category to be disabled by default.

Should not affect webrtc standalone. For chromium, disabling helps
mitigate viewing performance problems.

BUG=chromium:441440
R=mflodman@webrtc.org, stefan@webrtc.org

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

Cr-Commit-Position: refs/heads/master@{#8375}
git-svn-id: http://webrtc.googlecode.com/svn/trunk@8375 4adac7df-926f-26a2-2b94-8c16560cd09d

webrtc/modules/pacing/paced_sender.cc

@@ -22,7 +22,6 @@
 #include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
 #include "webrtc/system_wrappers/interface/field_trial.h"
 #include "webrtc/system_wrappers/interface/logging.h"
-#include "webrtc/system_wrappers/interface/trace_event.h"
 
 namespace {
 // Time limit in milliseconds between packet bursts.

webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc

@@ -394,9 +394,8 @@ RTCPReceiver::HandleSenderReceiverReport(RTCPUtility::RTCPParserV2& rtcpParser,
 
     if (rtcpPacketType == RTCPUtility::kRtcpSrCode)
     {
-        TRACE_EVENT_INSTANT2("webrtc_rtp", "SR",
-                             "remote_ssrc", remoteSSRC,
-                             "ssrc", main_ssrc_);
+      TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "SR",
+                           "remote_ssrc", remoteSSRC, "ssrc", main_ssrc_);
 
         if (_remoteSSRC == remoteSSRC) // have I received RTP packets from this party
         {
@@ -425,9 +424,8 @@ RTCPReceiver::HandleSenderReceiverReport(RTCPUtility::RTCPParserV2& rtcpParser,
         }
     } else
     {
-        TRACE_EVENT_INSTANT2("webrtc_rtp", "RR",
-                             "remote_ssrc", remoteSSRC,
-                             "ssrc", main_ssrc_);
+      TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RR",
+                           "remote_ssrc", remoteSSRC, "ssrc", main_ssrc_);
 
         rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpRr;
     }
@@ -555,7 +553,8 @@ void RTCPReceiver::HandleReportBlock(
     reportBlock->numAverageCalcs++;
   }
 
-  TRACE_COUNTER_ID1("webrtc_rtp", "RR_RTT", rb.SSRC, RTT);
+  TRACE_COUNTER_ID1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RR_RTT", rb.SSRC,
+                    RTT);
 
   rtcpPacketInformation.AddReportInfo(*reportBlock);
 }
@@ -986,7 +985,7 @@ void RTCPReceiver::HandlePLI(RTCPUtility::RTCPParserV2& rtcpParser,
                              RTCPPacketInformation& rtcpPacketInformation) {
   const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
   if (main_ssrc_ == rtcpPacket.PLI.MediaSSRC) {
-    TRACE_EVENT_INSTANT0("webrtc_rtp", "PLI");
+    TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "PLI");
 
     ++packet_type_counter_.pli_packets;
     // Received a signal that we need to send a new key frame.

webrtc/modules/rtp_rtcp/source/rtcp_sender.cc

@@ -1764,9 +1764,11 @@ int RTCPSender::PrepareRTCP(const FeedbackState& feedback_state,
       } else if (buildVal == -2) {
         return position;
       }
-      TRACE_EVENT_INSTANT0("webrtc_rtp", "RTCPSender::PLI");
+      TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
+                           "RTCPSender::PLI");
       ++packet_type_counter_.pli_packets;
-      TRACE_COUNTER_ID1("webrtc_rtp", "RTCP_PLICount", _SSRC,
+      TRACE_COUNTER_ID1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
+                        "RTCP_PLICount", _SSRC,
                         packet_type_counter_.pli_packets);
   }
   if(rtcpPacketTypeFlags & kRtcpFir)
@@ -1777,9 +1779,11 @@ int RTCPSender::PrepareRTCP(const FeedbackState& feedback_state,
       } else if (buildVal == -2) {
         return position;
       }
-      TRACE_EVENT_INSTANT0("webrtc_rtp", "RTCPSender::FIR");
+      TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
+                           "RTCPSender::FIR");
       ++packet_type_counter_.fir_packets;
-      TRACE_COUNTER_ID1("webrtc_rtp", "RTCP_FIRCount", _SSRC,
+      TRACE_COUNTER_ID1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
+                        "RTCP_FIRCount", _SSRC,
                         packet_type_counter_.fir_packets);
   }
   if(rtcpPacketTypeFlags & kRtcpSli)
@@ -1813,7 +1817,8 @@ int RTCPSender::PrepareRTCP(const FeedbackState& feedback_state,
       } else if (buildVal == -2) {
         return position;
       }
-      TRACE_EVENT_INSTANT0("webrtc_rtp", "RTCPSender::REMB");
+      TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
+                           "RTCPSender::REMB");
   }
   if(rtcpPacketTypeFlags & kRtcpBye)
   {
@@ -1861,10 +1866,12 @@ int RTCPSender::PrepareRTCP(const FeedbackState& feedback_state,
       } else if (buildVal == -2) {
         return position;
       }
-      TRACE_EVENT_INSTANT1("webrtc_rtp", "RTCPSender::NACK",
-                           "nacks", TRACE_STR_COPY(nackString.c_str()));
+      TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
+                           "RTCPSender::NACK", "nacks",
+                           TRACE_STR_COPY(nackString.c_str()));
       ++packet_type_counter_.nack_packets;
-      TRACE_COUNTER_ID1("webrtc_rtp", "RTCP_NACKCount", _SSRC,
+      TRACE_COUNTER_ID1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
+                        "RTCP_NACKCount", _SSRC,
                         packet_type_counter_.nack_packets);
   }
   if(rtcpPacketTypeFlags & kRtcpXrVoipMetric)

webrtc/modules/rtp_rtcp/source/rtp_receiver_audio.cc

@@ -187,9 +187,9 @@ int32_t RTPReceiverAudio::ParseRtpPacket(WebRtcRTPHeader* rtp_header,
                                          size_t payload_length,
                                          int64_t timestamp_ms,
                                          bool is_first_packet) {
-  TRACE_EVENT2("webrtc_rtp", "Audio::ParseRtp",
-               "seqnum", rtp_header->header.sequenceNumber,
-               "timestamp", rtp_header->header.timestamp);
+  TRACE_EVENT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "Audio::ParseRtp",
+               "seqnum", rtp_header->header.sequenceNumber, "timestamp",
+               rtp_header->header.timestamp);
   rtp_header->type.Audio.numEnergy = rtp_header->header.numCSRCs;
   num_energy_ = rtp_header->type.Audio.numEnergy;
   if (rtp_header->type.Audio.numEnergy > 0 &&

webrtc/modules/rtp_rtcp/source/rtp_receiver_video.cc

@@ -54,11 +54,8 @@ int32_t RTPReceiverVideo::ParseRtpPacket(WebRtcRTPHeader* rtp_header,
                                          size_t payload_length,
                                          int64_t timestamp_ms,
                                          bool is_first_packet) {
-  TRACE_EVENT2("webrtc_rtp",
-               "Video::ParseRtp",
-               "seqnum",
-               rtp_header->header.sequenceNumber,
-               "timestamp",
+  TRACE_EVENT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "Video::ParseRtp",
+               "seqnum", rtp_header->header.sequenceNumber, "timestamp",
                rtp_header->header.timestamp);
   rtp_header->type.Video.codec = specific_payload.Video.videoCodecType;
 

webrtc/modules/rtp_rtcp/source/rtp_sender.cc

@@ -685,8 +685,9 @@ bool RTPSender::SendPacketToNetwork(const uint8_t *packet, size_t size) {
   if (transport_) {
     bytes_sent = transport_->SendPacket(id_, packet, size);
   }
-  TRACE_EVENT_INSTANT2("webrtc_rtp", "RTPSender::SendPacketToNetwork",
-                       "size", size, "sent", bytes_sent);
+  TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
+                       "RTPSender::SendPacketToNetwork", "size", size, "sent",
+                       bytes_sent);
   // TODO(pwestin): Add a separate bitrate for sent bitrate after pacer.
   if (bytes_sent <= 0) {
     LOG(LS_WARNING) << "Transport failed to send packet";
@@ -709,8 +710,9 @@ int RTPSender::SetSelectiveRetransmissions(uint8_t settings) {
 
 void RTPSender::OnReceivedNACK(const std::list<uint16_t>& nack_sequence_numbers,
                                int64_t avg_rtt) {
-  TRACE_EVENT2("webrtc_rtp", "RTPSender::OnReceivedNACK",
-               "num_seqnum", nack_sequence_numbers.size(), "avg_rtt", avg_rtt);
+  TRACE_EVENT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
+               "RTPSender::OnReceivedNACK", "num_seqnum",
+               nack_sequence_numbers.size(), "avg_rtt", avg_rtt);
   const int64_t now = clock_->TimeInMilliseconds();
   uint32_t bytes_re_sent = 0;
   uint32_t target_bitrate = GetTargetBitrate();
@@ -840,12 +842,13 @@ bool RTPSender::PrepareAndSendPacket(uint8_t* buffer,
   RTPHeader rtp_header;
   rtp_parser.Parse(rtp_header);
   if (!is_retransmit && rtp_header.markerBit) {
-    TRACE_EVENT_ASYNC_END0("webrtc_rtp", "PacedSend", capture_time_ms);
+    TRACE_EVENT_ASYNC_END0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "PacedSend",
+                           capture_time_ms);
   }
 
-  TRACE_EVENT_INSTANT2("webrtc_rtp", "PrepareAndSendPacket",
-                       "timestamp", rtp_header.timestamp,
-                       "seqnum", rtp_header.sequenceNumber);
+  TRACE_EVENT_INSTANT2(
+      TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "PrepareAndSendPacket",
+      "timestamp", rtp_header.timestamp, "seqnum", rtp_header.sequenceNumber);
 
   uint8_t data_buffer_rtx[IP_PACKET_SIZE];
   if (send_over_rtx) {
@@ -969,7 +972,8 @@ int32_t RTPSender::SendToNetwork(
       if (last_capture_time_ms_sent_ == 0 ||
           corrected_time_ms > last_capture_time_ms_sent_) {
         last_capture_time_ms_sent_ = corrected_time_ms;
-        TRACE_EVENT_ASYNC_BEGIN1("webrtc_rtp", "PacedSend", corrected_time_ms,
+        TRACE_EVENT_ASYNC_BEGIN1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
+                                 "PacedSend", corrected_time_ms,
                                  "capture_time_ms", corrected_time_ms);
       }
       // We can't send the packet right now.

webrtc/modules/rtp_rtcp/source/rtp_sender_audio.cc

@@ -473,10 +473,10 @@ RTPSenderAudio::SendTelephoneEventPacket(bool ended,
         dtmfbuffer[13] = E|R|volume;
         RtpUtility::AssignUWord16ToBuffer(dtmfbuffer + 14, duration);
 
-        TRACE_EVENT_INSTANT2("webrtc_rtp",
-                             "Audio::SendTelephoneEvent",
-                             "timestamp", dtmfTimeStamp,
-                             "seqnum", _rtpSender->SequenceNumber());
+        TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
+                             "Audio::SendTelephoneEvent", "timestamp",
+                             dtmfTimeStamp, "seqnum",
+                             _rtpSender->SequenceNumber());
         retVal = _rtpSender->SendToNetwork(dtmfbuffer, 4, 12, -1,
                                            kAllowRetransmission,
                                            PacedSender::kHighPriority);

webrtc/modules/rtp_rtcp/source/rtp_sender_video.cc

@@ -108,12 +108,9 @@ int32_t RTPSenderVideo::SendVideoPacket(uint8_t* data_buffer,
 
     RedPacket* red_packet = producer_fec_.BuildRedPacket(
         data_buffer, payload_length, rtp_header_length, _payloadTypeRED);
-    TRACE_EVENT_INSTANT2("webrtc_rtp",
-                         "Video::PacketRed",
-                         "timestamp",
-                         capture_timestamp,
-                         "seqnum",
-                         _rtpSender.SequenceNumber());
+    TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
+                         "Video::PacketRed", "timestamp", capture_timestamp,
+                         "seqnum", _rtpSender.SequenceNumber());
     // Sending the media packet with RED header.
     int packet_success =
         _rtpSender.SendToNetwork(red_packet->data(),
@@ -148,12 +145,9 @@ int32_t RTPSenderVideo::SendVideoPacket(uint8_t* data_buffer,
       if (_retransmissionSettings & kRetransmitFECPackets) {
         storage = kAllowRetransmission;
       }
-      TRACE_EVENT_INSTANT2("webrtc_rtp",
-                           "Video::PacketFec",
-                           "timestamp",
-                           capture_timestamp,
-                           "seqnum",
-                           _rtpSender.SequenceNumber());
+      TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
+                           "Video::PacketFec", "timestamp", capture_timestamp,
+                           "seqnum", _rtpSender.SequenceNumber());
       // Sending FEC packet with RED header.
       int packet_success =
           _rtpSender.SendToNetwork(red_packet->data(),
@@ -175,12 +169,9 @@ int32_t RTPSenderVideo::SendVideoPacket(uint8_t* data_buffer,
     _fecOverheadRate.Update(fec_overhead_sent);
     return ret;
   }
-  TRACE_EVENT_INSTANT2("webrtc_rtp",
-                       "Video::PacketNormal",
-                       "timestamp",
-                       capture_timestamp,
-                       "seqnum",
-                       _rtpSender.SequenceNumber());
+  TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
+                       "Video::PacketNormal", "timestamp", capture_timestamp,
+                       "seqnum", _rtpSender.SequenceNumber());
   int ret = _rtpSender.SendToNetwork(data_buffer,
                                      payload_length,
                                      rtp_header_length,
@@ -206,9 +197,8 @@ int32_t RTPSenderVideo::SendRTPIntraRequest() {
 
   RtpUtility::AssignUWord32ToBuffer(data + 4, _rtpSender.SSRC());
 
-  TRACE_EVENT_INSTANT1("webrtc_rtp",
-                       "Video::IntraRequest",
-                       "seqnum",
+  TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
+                       "Video::IntraRequest", "seqnum",
                        _rtpSender.SequenceNumber());
   return _rtpSender.SendToNetwork(
       data, 0, length, -1, kDontStore, PacedSender::kNormalPriority);

webrtc/modules/video_coding/main/source/jitter_buffer.cc

@@ -950,7 +950,8 @@ bool VCMJitterBuffer::UpdateNackList(uint16_t sequence_number) {
     for (uint16_t i = latest_received_sequence_number_ + 1;
          IsNewerSequenceNumber(sequence_number, i); ++i) {
       missing_sequence_numbers_.insert(missing_sequence_numbers_.end(), i);
-      TRACE_EVENT_INSTANT1("webrtc", "AddNack", "seqnum", i);
+      TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "AddNack",
+                           "seqnum", i);
     }
     if (TooLargeNackList() && !HandleTooLargeNackList()) {
       LOG(LS_WARNING) << "Requesting key frame due to too large NACK list.";
@@ -963,7 +964,8 @@ bool VCMJitterBuffer::UpdateNackList(uint16_t sequence_number) {
     }
   } else {
     missing_sequence_numbers_.erase(sequence_number);
-    TRACE_EVENT_INSTANT1("webrtc", "RemoveNack", "seqnum", sequence_number);
+    TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RemoveNack",
+                         "seqnum", sequence_number);
   }
   return true;
 }

webrtc/modules/video_coding/main/source/video_coding_impl.cc

@@ -16,7 +16,6 @@
 #include "webrtc/modules/video_coding/main/source/packet.h"
 #include "webrtc/modules/video_coding/main/source/video_coding_impl.h"
 #include "webrtc/system_wrappers/interface/clock.h"
-#include "webrtc/system_wrappers/interface/trace_event.h"
 
 namespace webrtc {
 namespace vcm {

webrtc/system_wrappers/interface/trace_event.h

@@ -147,6 +147,10 @@
 #define TRACE_STR_COPY(str) \
     webrtc::trace_event_internal::TraceStringWithCopy(str)
 
+// This will mark the trace event as disabled by default. The user will need
+// to explicitly enable the event.
+#define TRACE_DISABLED_BY_DEFAULT(name) "disabled-by-default-" name
+
 // By default, uint64 ID argument values are not mangled with the Process ID in
 // TRACE_EVENT_ASYNC macros. Use this macro to force Process ID mangling.
 #define TRACE_ID_MANGLE(id) \