Add RTC_ prefix to (D)CHECKs and related macros.

talk/app/webrtc/statscollector.cc

 /*
  * libjingle
  * Copyright 2012 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 53 matching lines @@
   const ValueType& value;
 };
 
 typedef TypeForAdd<bool> BoolForAdd;
 typedef TypeForAdd<float> FloatForAdd;
 typedef TypeForAdd<int64> Int64ForAdd;
 typedef TypeForAdd<int> IntForAdd;
 
 StatsReport::Id GetTransportIdFromProxy(const cricket::ProxyTransportMap& map,
                                         const std::string& proxy) {
-  DCHECK(!proxy.empty());
+  RTC_DCHECK(!proxy.empty());
   cricket::ProxyTransportMap::const_iterator found = map.find(proxy);
   if (found == map.end())
     return StatsReport::Id();
 
   return StatsReport::NewComponentId(
       found->second, cricket::ICE_CANDIDATE_COMPONENT_RTP);
 }
 
 StatsReport* AddTrackReport(StatsCollection* reports,
                             const std::string& track_id) {
   // Adds an empty track report.
   StatsReport::Id id(
       StatsReport::NewTypedId(StatsReport::kStatsReportTypeTrack, track_id));
   StatsReport* report = reports->ReplaceOrAddNew(id);
   report->AddString(StatsReport::kStatsValueNameTrackId, track_id);
   return report;
 }
 
 template <class TrackVector>
 void CreateTrackReports(const TrackVector& tracks, StatsCollection* reports,
                         TrackIdMap& track_ids) {
   for (const auto& track : tracks) {
     const std::string& track_id = track->id();
     StatsReport* report = AddTrackReport(reports, track_id);
-    DCHECK(report != nullptr);
+    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);
 }
@@ skipping 144 matching lines @@
   };
 
   for (const auto& i : ints)
     report->AddInt(i.name, i.value);
 }
 
 void ExtractStats(const cricket::BandwidthEstimationInfo& info,
                   double stats_gathering_started,
                   PeerConnectionInterface::StatsOutputLevel level,
                   StatsReport* report) {
-  DCHECK(report->type() == StatsReport::kStatsReportTypeBwe);
+  RTC_DCHECK(report->type() == StatsReport::kStatsReportTypeBwe);
 
   report->set_timestamp(stats_gathering_started);
   const IntForAdd ints[] = {
     { StatsReport::kStatsValueNameAvailableSendBandwidth,
       info.available_send_bandwidth },
     { StatsReport::kStatsValueNameAvailableReceiveBandwidth,
       info.available_recv_bandwidth },
     { StatsReport::kStatsValueNameTargetEncBitrate, info.target_enc_bitrate },
     { StatsReport::kStatsValueNameActualEncBitrate, info.actual_enc_bitrate },
     { StatsReport::kStatsValueNameRetransmitBitrate, info.retransmit_bitrate },
@@ skipping 50 matching lines @@
   }
   if (candidate_type == cricket::STUN_PORT_TYPE) {
     return STATSREPORT_STUN_PORT_TYPE;
   }
   if (candidate_type == cricket::PRFLX_PORT_TYPE) {
     return STATSREPORT_PRFLX_PORT_TYPE;
   }
   if (candidate_type == cricket::RELAY_PORT_TYPE) {
     return STATSREPORT_RELAY_PORT_TYPE;
   }
-  DCHECK(false);
+  RTC_DCHECK(false);
   return "unknown";
 }
 
 const char* AdapterTypeToStatsType(rtc::AdapterType type) {
   switch (type) {
     case rtc::ADAPTER_TYPE_UNKNOWN:
       return "unknown";
     case rtc::ADAPTER_TYPE_ETHERNET:
       return STATSREPORT_ADAPTER_TYPE_ETHERNET;
     case rtc::ADAPTER_TYPE_WIFI:
       return STATSREPORT_ADAPTER_TYPE_WIFI;
     case rtc::ADAPTER_TYPE_CELLULAR:
       return STATSREPORT_ADAPTER_TYPE_WWAN;
     case rtc::ADAPTER_TYPE_VPN:
       return STATSREPORT_ADAPTER_TYPE_VPN;
     case rtc::ADAPTER_TYPE_LOOPBACK:
       return STATSREPORT_ADAPTER_TYPE_LOOPBACK;
     default:
-      DCHECK(false);
+      RTC_DCHECK(false);
       return "";
   }
 }
 
 StatsCollector::StatsCollector(WebRtcSession* session)
     : session_(session),
       stats_gathering_started_(0) {
-  DCHECK(session_);
+  RTC_DCHECK(session_);
 }
 
 StatsCollector::~StatsCollector() {
-  DCHECK(session_->signaling_thread()->IsCurrent());
+  RTC_DCHECK(session_->signaling_thread()->IsCurrent());
 }
 
 double StatsCollector::GetTimeNow() {
   return rtc::Timing::WallTimeNow() * rtc::kNumMillisecsPerSec;
 }
 
 // Adds a MediaStream with tracks that can be used as a |selector| in a call
 // to GetStats.
 void StatsCollector::AddStream(MediaStreamInterface* stream) {
-  DCHECK(session_->signaling_thread()->IsCurrent());
-  DCHECK(stream != NULL);
+  RTC_DCHECK(session_->signaling_thread()->IsCurrent());
+  RTC_DCHECK(stream != NULL);
 
   CreateTrackReports<AudioTrackVector>(stream->GetAudioTracks(),
                                        &reports_, track_ids_);
   CreateTrackReports<VideoTrackVector>(stream->GetVideoTracks(),
                                        &reports_, track_ids_);
 }
 
 void StatsCollector::AddLocalAudioTrack(AudioTrackInterface* audio_track,
                                         uint32 ssrc) {
-  DCHECK(session_->signaling_thread()->IsCurrent());
-  DCHECK(audio_track != NULL);
+  RTC_DCHECK(session_->signaling_thread()->IsCurrent());
+  RTC_DCHECK(audio_track != NULL);
 #if (!defined(NDEBUG) || defined(DCHECK_ALWAYS_ON))
   for (const auto& track : local_audio_tracks_)
-    DCHECK(track.first != audio_track || track.second != ssrc);
+    RTC_DCHECK(track.first != audio_track || track.second != ssrc);
 #endif
 
   local_audio_tracks_.push_back(std::make_pair(audio_track, ssrc));
 
   // Create the kStatsReportTypeTrack report for the new track if there is no
   // report yet.
   StatsReport::Id id(StatsReport::NewTypedId(StatsReport::kStatsReportTypeTrack,
                                              audio_track->id()));
   StatsReport* report = reports_.Find(id);
   if (!report) {
     report = reports_.InsertNew(id);
     report->AddString(StatsReport::kStatsValueNameTrackId, audio_track->id());
   }
 }
 
 void StatsCollector::RemoveLocalAudioTrack(AudioTrackInterface* audio_track,
                                            uint32 ssrc) {
-  DCHECK(audio_track != NULL);
+  RTC_DCHECK(audio_track != NULL);
   local_audio_tracks_.erase(std::remove_if(local_audio_tracks_.begin(),
       local_audio_tracks_.end(),
       [audio_track, ssrc](const LocalAudioTrackVector::value_type& track) {
         return track.first == audio_track && track.second == ssrc;
       }));
 }
 
 void StatsCollector::GetStats(MediaStreamTrackInterface* track,
                               StatsReports* reports) {
-  DCHECK(session_->signaling_thread()->IsCurrent());
-  DCHECK(reports != NULL);
-  DCHECK(reports->empty());
+  RTC_DCHECK(session_->signaling_thread()->IsCurrent());
+  RTC_DCHECK(reports != NULL);
+  RTC_DCHECK(reports->empty());
 
   rtc::Thread::ScopedDisallowBlockingCalls no_blocking_calls;
 
   if (!track) {
     reports->reserve(reports_.size());
     for (auto* r : reports_)
       reports->push_back(r);
     return;
   }
 
@@ skipping 17 matching lines @@
 
     const StatsReport::Value* v =
         r->FindValue(StatsReport::kStatsValueNameTrackId);
     if (v && v->string_val() == track->id())
       reports->push_back(r);
   }
 }
 
 void
 StatsCollector::UpdateStats(PeerConnectionInterface::StatsOutputLevel level) {
-  DCHECK(session_->signaling_thread()->IsCurrent());
+  RTC_DCHECK(session_->signaling_thread()->IsCurrent());
   double time_now = GetTimeNow();
   // Calls to UpdateStats() that occur less than kMinGatherStatsPeriod number of
   // ms apart will be ignored.
   const double kMinGatherStatsPeriod = 50;
   if (stats_gathering_started_ != 0 &&
       stats_gathering_started_ + kMinGatherStatsPeriod > time_now) {
     return;
   }
   stats_gathering_started_ = time_now;
 
@@ skipping 10 matching lines @@
     ExtractDataInfo();
     UpdateTrackReports();
   }
 }
 
 StatsReport* StatsCollector::PrepareReport(
     bool local,
     uint32 ssrc,
     const StatsReport::Id& transport_id,
     StatsReport::Direction direction) {
-  DCHECK(session_->signaling_thread()->IsCurrent());
+  RTC_DCHECK(session_->signaling_thread()->IsCurrent());
   StatsReport::Id id(StatsReport::NewIdWithDirection(
       local ? StatsReport::kStatsReportTypeSsrc :
               StatsReport::kStatsReportTypeRemoteSsrc,
       rtc::ToString<uint32>(ssrc), direction));
   StatsReport* report = reports_.Find(id);
 
   // Use the ID of the track that is currently mapped to the SSRC, if any.
   std::string track_id;
   if (!GetTrackIdBySsrc(ssrc, &track_id, direction)) {
     if (!report) {
@@ skipping 18 matching lines @@
 
   report->AddInt64(StatsReport::kStatsValueNameSsrc, ssrc);
   report->AddString(StatsReport::kStatsValueNameTrackId, track_id);
   // Add the mapping of SSRC to transport.
   report->AddId(StatsReport::kStatsValueNameTransportId, transport_id);
   return report;
 }
 
 StatsReport* StatsCollector::AddOneCertificateReport(
     const rtc::SSLCertificate* cert, const StatsReport* issuer) {
-  DCHECK(session_->signaling_thread()->IsCurrent());
+  RTC_DCHECK(session_->signaling_thread()->IsCurrent());
 
   // TODO(bemasc): Move this computation to a helper class that caches these
   // values to reduce CPU use in GetStats.  This will require adding a fast
   // SSLCertificate::Equals() method to detect certificate changes.
 
   std::string digest_algorithm;
   if (!cert->GetSignatureDigestAlgorithm(&digest_algorithm))
     return nullptr;
 
   rtc::scoped_ptr<rtc::SSLFingerprint> ssl_fingerprint(
@@ skipping 22 matching lines @@
   report->AddString(StatsReport::kStatsValueNameFingerprintAlgorithm,
                     digest_algorithm);
   report->AddString(StatsReport::kStatsValueNameDer, der_base64);
   if (issuer)
     report->AddId(StatsReport::kStatsValueNameIssuerId, issuer->id());
   return report;
 }
 
 StatsReport* StatsCollector::AddCertificateReports(
     const rtc::SSLCertificate* cert) {
-  DCHECK(session_->signaling_thread()->IsCurrent());
+  RTC_DCHECK(session_->signaling_thread()->IsCurrent());
   // Produces a chain of StatsReports representing this certificate and the rest
   // of its chain, and adds those reports to |reports_|.  The return value is
   // the id of the leaf report.  The provided cert must be non-null, so at least
   // one report will always be provided and the returned string will never be
   // empty.
-  DCHECK(cert != NULL);
+  RTC_DCHECK(cert != NULL);
 
   StatsReport* issuer = nullptr;
   rtc::scoped_ptr<rtc::SSLCertChain> chain;
   if (cert->GetChain(chain.accept())) {
     // This loop runs in reverse, i.e. from root to leaf, so that each
     // certificate's issuer's report ID is known before the child certificate's
     // report is generated.  The root certificate does not have an issuer ID
     // value.
     for (ptrdiff_t i = chain->GetSize() - 1; i >= 0; --i) {
       const rtc::SSLCertificate& cert_i = chain->Get(i);
@@ skipping 73 matching lines @@
     report->AddString(StatsReport::kStatsValueNameCandidateType,
                       IceCandidateTypeToStatsType(candidate.type()));
     report->AddString(StatsReport::kStatsValueNameCandidateTransportType,
                       candidate.protocol());
   }
 
   return report;
 }
 
 void StatsCollector::ExtractSessionInfo() {
-  DCHECK(session_->signaling_thread()->IsCurrent());
+  RTC_DCHECK(session_->signaling_thread()->IsCurrent());
 
   // Extract information from the base session.
   StatsReport::Id id(StatsReport::NewTypedId(
       StatsReport::kStatsReportTypeSession, session_->id()));
   StatsReport* report = reports_.ReplaceOrAddNew(id);
   report->set_timestamp(stats_gathering_started_);
   report->AddBoolean(StatsReport::kStatsValueNameInitiator,
                      session_->initiator());
 
   cricket::SessionStats stats;
@@ skipping 73 matching lines @@
           channel_report->AddId(
               StatsReport::kStatsValueNameSelectedCandidatePairId,
               connection_report->id());
         }
       }
     }
   }
 }
 
 void StatsCollector::ExtractVoiceInfo() {
-  DCHECK(session_->signaling_thread()->IsCurrent());
+  RTC_DCHECK(session_->signaling_thread()->IsCurrent());
 
   if (!session_->voice_channel()) {
     return;
   }
   cricket::VoiceMediaInfo voice_info;
   if (!session_->voice_channel()->GetStats(&voice_info)) {
     LOG(LS_ERROR) << "Failed to get voice channel stats.";
     return;
   }
 
@@ skipping 12 matching lines @@
   ExtractStatsFromList(voice_info.receivers, transport_id, this,
       StatsReport::kReceive);
   ExtractStatsFromList(voice_info.senders, transport_id, this,
       StatsReport::kSend);
 
   UpdateStatsFromExistingLocalAudioTracks();
 }
 
 void StatsCollector::ExtractVideoInfo(
     PeerConnectionInterface::StatsOutputLevel level) {
-  DCHECK(session_->signaling_thread()->IsCurrent());
+  RTC_DCHECK(session_->signaling_thread()->IsCurrent());
 
   if (!session_->video_channel())
     return;
 
   cricket::VideoMediaInfo video_info;
   if (!session_->video_channel()->GetStats(&video_info)) {
     LOG(LS_ERROR) << "Failed to get video channel stats.";
     return;
   }
 
@@ skipping 16 matching lines @@
     LOG(LS_ERROR) << "BWEs count: " << video_info.bw_estimations.size();
   } else {
     StatsReport::Id report_id(StatsReport::NewBandwidthEstimationId());
     StatsReport* report = reports_.FindOrAddNew(report_id);
     ExtractStats(
         video_info.bw_estimations[0], stats_gathering_started_, level, report);
   }
 }
 
 void StatsCollector::ExtractDataInfo() {
-  DCHECK(session_->signaling_thread()->IsCurrent());
+  RTC_DCHECK(session_->signaling_thread()->IsCurrent());
 
   rtc::Thread::ScopedDisallowBlockingCalls no_blocking_calls;
 
   for (const auto& dc :
            session_->mediastream_signaling()->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());
     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) {
-  DCHECK(session_->signaling_thread()->IsCurrent());
-  DCHECK(type == StatsReport::kStatsReportTypeSsrc ||
-         type == StatsReport::kStatsReportTypeRemoteSsrc);
+  RTC_DCHECK(session_->signaling_thread()->IsCurrent());
+  RTC_DCHECK(type == StatsReport::kStatsReportTypeSsrc ||
+             type == StatsReport::kStatsReportTypeRemoteSsrc);
   return reports_.Find(StatsReport::NewIdWithDirection(type, id, direction));
 }
 
 void StatsCollector::UpdateStatsFromExistingLocalAudioTracks() {
-  DCHECK(session_->signaling_thread()->IsCurrent());
+  RTC_DCHECK(session_->signaling_thread()->IsCurrent());
   // Loop through the existing local audio tracks.
   for (const auto& it : local_audio_tracks_) {
     AudioTrackInterface* track = it.first;
     uint32 ssrc = it.second;
     StatsReport* report = GetReport(StatsReport::kStatsReportTypeSsrc,
                                     rtc::ToString<uint32>(ssrc),
                                     StatsReport::kSend);
     if (report == NULL) {
       // This can happen if a local audio track is added to a stream on the
       // fly and the report has not been set up yet. Do nothing in this case.
       LOG(LS_ERROR) << "Stats report does not exist for ssrc " << ssrc;
       continue;
     }
 
     // The same ssrc can be used by both local and remote audio tracks.
     const StatsReport::Value* v =
         report->FindValue(StatsReport::kStatsValueNameTrackId);
     if (!v || v->string_val() != track->id())
       continue;
 
     report->set_timestamp(stats_gathering_started_);
     UpdateReportFromAudioTrack(track, report);
   }
 }
 
 void StatsCollector::UpdateReportFromAudioTrack(AudioTrackInterface* track,
                                                 StatsReport* report) {
-  DCHECK(session_->signaling_thread()->IsCurrent());
-  DCHECK(track != NULL);
+  RTC_DCHECK(session_->signaling_thread()->IsCurrent());
+  RTC_DCHECK(track != NULL);
 
   int signal_level = 0;
   if (!track->GetSignalLevel(&signal_level))
     signal_level = -1;
 
   rtc::scoped_refptr<AudioProcessorInterface> audio_processor(
       track->GetAudioProcessor());
 
   AudioProcessorInterface::AudioProcessorStats stats;
   if (audio_processor.get())
     audio_processor->GetStats(&stats);
 
   SetAudioProcessingStats(report, signal_level, stats.typing_noise_detected,
       stats.echo_return_loss, stats.echo_return_loss_enhancement,
       stats.echo_delay_median_ms, stats.aec_quality_min,
       stats.echo_delay_std_ms);
 }
 
 bool StatsCollector::GetTrackIdBySsrc(uint32 ssrc, std::string* track_id,
                                       StatsReport::Direction direction) {
-  DCHECK(session_->signaling_thread()->IsCurrent());
+  RTC_DCHECK(session_->signaling_thread()->IsCurrent());
   if (direction == StatsReport::kSend) {
     if (!session_->GetLocalTrackIdBySsrc(ssrc, track_id)) {
       LOG(LS_WARNING) << "The SSRC " << ssrc
                       << " is not associated with a sending track";
       return false;
     }
   } else {
-    DCHECK(direction == StatsReport::kReceive);
+    RTC_DCHECK(direction == StatsReport::kReceive);
     if (!session_->GetRemoteTrackIdBySsrc(ssrc, track_id)) {
       LOG(LS_WARNING) << "The SSRC " << ssrc
                       << " is not associated with a receiving track";
       return false;
     }
   }
 
   return true;
 }
 
 void StatsCollector::UpdateTrackReports() {
-  DCHECK(session_->signaling_thread()->IsCurrent());
+  RTC_DCHECK(session_->signaling_thread()->IsCurrent());
 
   rtc::Thread::ScopedDisallowBlockingCalls no_blocking_calls;
 
   for (const auto& entry : track_ids_) {
     StatsReport* report = entry.second;
     report->set_timestamp(stats_gathering_started_);
   }
 
 }
 
 void StatsCollector::ClearUpdateStatsCacheForTest() {
   stats_gathering_started_ = 0;
 }
 
 }  // namespace webrtc