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

talk/app/webrtc/statstypes.cc

 /*
  * libjingle
  * Copyright 2014 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 14 matching lines @@
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "talk/app/webrtc/statstypes.h"
 
 #include <string.h>
 
 #include "webrtc/base/checks.h"
 
 // TODO(tommi): Could we have a static map of value name -> expected type
-// and use this to DCHECK on correct usage (somewhat strongly typed values)?
+// and use this to RTC_DCHECK on correct usage (somewhat strongly typed values)?
 // Alternatively, we could define the names+type in a separate document and
 // generate strongly typed inline C++ code that forces the correct type to be
 // used for a given name at compile time.
 
 using rtc::RefCountedObject;
 
 namespace webrtc {
 namespace {
 
 // The id of StatsReport of type kStatsReportTypeBwe.
@@ skipping 21 matching lines @@
       return "transport";
     case StatsReport::kStatsReportTypeComponent:
       return "googComponent";
     case StatsReport::kStatsReportTypeCandidatePair:
       return "googCandidatePair";
     case StatsReport::kStatsReportTypeCertificate:
       return "googCertificate";
     case StatsReport::kStatsReportTypeDataChannel:
       return "datachannel";
   }
-  DCHECK(false);
+  RTC_DCHECK(false);
   return nullptr;
 }
 
 class BandwidthEstimationId : public StatsReport::IdBase {
  public:
   BandwidthEstimationId()
       : StatsReport::IdBase(StatsReport::kStatsReportTypeBwe) {}
   std::string ToString() const override { return kStatsReportVideoBweId; }
 };
 
@@ skipping 136 matching lines @@
 StatsReport::IdBase::~IdBase() {}
 
 StatsReport::StatsType StatsReport::IdBase::type() const { return type_; }
 
 bool StatsReport::IdBase::Equals(const IdBase& other) const {
   return other.type_ == type_;
 }
 
 StatsReport::Value::Value(StatsValueName name, int64 value, Type int_type)
     : name(name), type_(int_type) {
-  DCHECK(type_ == kInt || type_ == kInt64);
+  RTC_DCHECK(type_ == kInt || type_ == kInt64);
   type_ == kInt ? value_.int_ = static_cast<int>(value) : value_.int64_ = value;
 }
 
 StatsReport::Value::Value(StatsValueName name, float f)
     : name(name), type_(kFloat) {
   value_.float_ = f;
 }
 
 StatsReport::Value::Value(StatsValueName name, const std::string& value)
     : name(name), type_(kString) {
@@ skipping 31 matching lines @@
       break;
   }
 }
 
 bool StatsReport::Value::Equals(const Value& other) const {
   if (name != other.name)
     return false;
 
   // There's a 1:1 relation between a name and a type, so we don't have to
   // check that.
-  DCHECK_EQ(type_, other.type_);
+  RTC_DCHECK_EQ(type_, other.type_);
 
   switch (type_) {
     case kInt:
       return value_.int_ == other.value_.int_;
     case kInt64:
       return value_.int64_ == other.value_.int64_;
     case kFloat:
       return value_.float_ == other.value_.float_;
     case kStaticString: {
 #if (!defined(NDEBUG) || defined(DCHECK_ALWAYS_ON))
       if (value_.static_string_ != other.value_.static_string_) {
-        DCHECK(strcmp(value_.static_string_, other.value_.static_string_) != 0)
+        RTC_DCHECK(strcmp(value_.static_string_, other.value_.static_string_) !=
+                   0)
             << "Duplicate global?";
       }
 #endif
       return value_.static_string_ == other.value_.static_string_;
     }
     case kString:
       return *value_.string_ == *other.value_.string_;
     case kBool:
       return value_.bool_ == other.value_.bool_;
     case kId:
       return (*value_.id_)->Equals(*other.value_.id_);
   }
   RTC_NOTREACHED();
   return false;
 }
 
 bool StatsReport::Value::operator==(const std::string& value) const {
   return (type_ == kString && value_.string_->compare(value) == 0) ||
          (type_ == kStaticString && value.compare(value_.static_string_) == 0);
 }
 
 bool StatsReport::Value::operator==(const char* value) const {
   if (type_ == kString)
     return value_.string_->compare(value) == 0;
   if (type_ != kStaticString)
     return false;
 #if (!defined(NDEBUG) || defined(DCHECK_ALWAYS_ON))
   if (value_.static_string_ != value)
-    DCHECK(strcmp(value_.static_string_, value) != 0) << "Duplicate global?";
+    RTC_DCHECK(strcmp(value_.static_string_, value) != 0)
+        << "Duplicate global?";
 #endif
   return value == value_.static_string_;
 }
 
 bool StatsReport::Value::operator==(int64 value) const {
   return type_ == kInt ? value_.int_ == static_cast<int>(value) :
       (type_ == kInt64 ? value_.int64_ == value : false);
 }
 
 bool StatsReport::Value::operator==(bool value) const {
   return type_ == kBool && value_.bool_ == value;
 }
 
 bool StatsReport::Value::operator==(float value) const {
   return type_ == kFloat && value_.float_ == value;
 }
 
 bool StatsReport::Value::operator==(const Id& value) const {
   return type_ == kId && (*value_.id_)->Equals(value);
 }
 
 int StatsReport::Value::int_val() const {
-  DCHECK(type_ == kInt);
+  RTC_DCHECK(type_ == kInt);
   return value_.int_;
 }
 
 int64 StatsReport::Value::int64_val() const {
-  DCHECK(type_ == kInt64);
+  RTC_DCHECK(type_ == kInt64);
   return value_.int64_;
 }
 
 float StatsReport::Value::float_val() const {
-  DCHECK(type_ == kFloat);
+  RTC_DCHECK(type_ == kFloat);
   return value_.float_;
 }
 
 const char* StatsReport::Value::static_string_val() const {
-  DCHECK(type_ == kStaticString);
+  RTC_DCHECK(type_ == kStaticString);
   return value_.static_string_;
 }
 
 const std::string& StatsReport::Value::string_val() const {
-  DCHECK(type_ == kString);
+  RTC_DCHECK(type_ == kString);
   return *value_.string_;
 }
 
 bool StatsReport::Value::bool_val() const {
-  DCHECK(type_ == kBool);
+  RTC_DCHECK(type_ == kBool);
   return value_.bool_;
 }
 
 const char* StatsReport::Value::display_name() const {
   switch (name) {
     case kStatsValueNameAudioOutputLevel:
       return "audioOutputLevel";
     case kStatsValueNameAudioInputLevel:
       return "audioInputLevel";
     case kStatsValueNameBytesSent:
@@ skipping 198 matching lines @@
       return "googTransportType";
     case kStatsValueNameTrackId:
       return "googTrackId";
     case kStatsValueNameTypingNoiseState:
       return "googTypingNoiseState";
     case kStatsValueNameViewLimitedResolution:
       return "googViewLimitedResolution";
     case kStatsValueNameWritable:
       return "googWritable";
     default:
-      DCHECK(false);
+      RTC_DCHECK(false);
       break;
   }
 
   return nullptr;
 }
 
 std::string StatsReport::Value::ToString() const {
   switch (type_) {
     case kInt:
       return rtc::ToString(value_.int_);
     case kInt64:
       return rtc::ToString(value_.int64_);
     case kFloat:
       return rtc::ToString(value_.float_);
     case kStaticString:
       return std::string(value_.static_string_);
     case kString:
       return *value_.string_;
     case kBool:
       return value_.bool_ ? "true" : "false";
     case kId:
       return (*value_.id_)->ToString();
   }
   RTC_NOTREACHED();
   return std::string();
 }
 
 StatsReport::StatsReport(const Id& id) : id_(id), timestamp_(0.0) {
-  DCHECK(id_.get());
+  RTC_DCHECK(id_.get());
 }
 
 // static
 StatsReport::Id StatsReport::NewBandwidthEstimationId() {
   return Id(new RefCountedObject<BandwidthEstimationId>());
 }
 
 // static
 StatsReport::Id StatsReport::NewTypedId(StatsType type, const std::string& id) {
   return Id(new RefCountedObject<TypedId>(type, id));
@@ skipping 79 matching lines @@
 
 const StatsReport::Value* StatsReport::FindValue(StatsValueName name) const {
   Values::const_iterator it = values_.find(name);
   return it == values_.end() ? nullptr : it->second.get();
 }
 
 StatsCollection::StatsCollection() {
 }
 
 StatsCollection::~StatsCollection() {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   for (auto* r : list_)
     delete r;
 }
 
 StatsCollection::const_iterator StatsCollection::begin() const {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   return list_.begin();
 }
 
 StatsCollection::const_iterator StatsCollection::end() const {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   return list_.end();
 }
 
 size_t StatsCollection::size() const {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   return list_.size();
 }
 
 StatsReport* StatsCollection::InsertNew(const StatsReport::Id& id) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(Find(id) == nullptr);
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
+  RTC_DCHECK(Find(id) == nullptr);
   StatsReport* report = new StatsReport(id);
   list_.push_back(report);
   return report;
 }
 
 StatsReport* StatsCollection::FindOrAddNew(const StatsReport::Id& id) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   StatsReport* ret = Find(id);
   return ret ? ret : InsertNew(id);
 }
 
 StatsReport* StatsCollection::ReplaceOrAddNew(const StatsReport::Id& id) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(id.get());
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
+  RTC_DCHECK(id.get());
   Container::iterator it = std::find_if(list_.begin(), list_.end(),
       [&id](const StatsReport* r)->bool { return r->id()->Equals(id); });
   if (it != end()) {
     StatsReport* report = new StatsReport((*it)->id());
     delete *it;
     *it = report;
     return report;
   }
   return InsertNew(id);
 }
 
 // Looks for a report with the given |id|.  If one is not found, NULL
 // will be returned.
 StatsReport* StatsCollection::Find(const StatsReport::Id& id) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   Container::iterator it = std::find_if(list_.begin(), list_.end(),
       [&id](const StatsReport* r)->bool { return r->id()->Equals(id); });
   return it == list_.end() ? nullptr : *it;
 }
 
 }  // namespace webrtc