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

talk/app/webrtc/webrtcsessiondescriptionfactory.cc

 /*
  * libjingle
  * Copyright 2013 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 172 matching lines @@
     : WebRtcSessionDescriptionFactory(
         signaling_thread,
         channel_manager,
         mediastream_signaling,
         dtls_identity_store.Pass(),
         new rtc::RefCountedObject<WebRtcIdentityRequestObserver>(),
         session,
         session_id,
         dct,
         true) {
-  DCHECK(dtls_identity_store_);
+  RTC_DCHECK(dtls_identity_store_);
 
   certificate_request_state_ = CERTIFICATE_WAITING;
 
   identity_request_observer_->SignalRequestFailed.connect(
       this, &WebRtcSessionDescriptionFactory::OnIdentityRequestFailed);
   identity_request_observer_->SignalCertificateReady.connect(
       this, &WebRtcSessionDescriptionFactory::SetCertificate);
 
   rtc::KeyType key_type = rtc::KT_DEFAULT;
   LOG(LS_VERBOSE) << "DTLS-SRTP enabled; sending DTLS identity request (key "
                   << "type: " << key_type << ").";
 
   // Request identity. This happens asynchronously, so the caller will have a
   // chance to connect to SignalIdentityReady.
   dtls_identity_store_->RequestIdentity(key_type, identity_request_observer_);
 }
 
 WebRtcSessionDescriptionFactory::WebRtcSessionDescriptionFactory(
     rtc::Thread* signaling_thread,
     cricket::ChannelManager* channel_manager,
     MediaStreamSignaling* mediastream_signaling,
     const rtc::scoped_refptr<rtc::RTCCertificate>& certificate,
     WebRtcSession* session,
     const std::string& session_id,
     cricket::DataChannelType dct)
     : WebRtcSessionDescriptionFactory(
         signaling_thread, channel_manager, mediastream_signaling, nullptr,
         nullptr, session, session_id, dct, true) {
-  DCHECK(certificate);
+  RTC_DCHECK(certificate);
 
   certificate_request_state_ = CERTIFICATE_WAITING;
 
   LOG(LS_VERBOSE) << "DTLS-SRTP enabled; has certificate parameter.";
   // We already have a certificate but we wait to do SetIdentity; if we do
   // it in the constructor then the caller has not had a chance to connect to
   // SignalIdentityReady.
   signaling_thread_->Post(this, MSG_USE_CONSTRUCTOR_CERTIFICATE,
                           new rtc::ScopedRefMessageData<rtc::RTCCertificate>(
                               certificate));
@@ skipping 277 matching lines @@
   ASSERT(signaling_thread_->IsCurrent());
 
   LOG(LS_ERROR) << "Async identity request failed: error = " << error;
   certificate_request_state_ = CERTIFICATE_FAILED;
 
   FailPendingRequests(kFailedDueToIdentityFailed);
 }
 
 void WebRtcSessionDescriptionFactory::SetCertificate(
     const rtc::scoped_refptr<rtc::RTCCertificate>& certificate) {
-  DCHECK(certificate);
+  RTC_DCHECK(certificate);
   LOG(LS_VERBOSE) << "Setting new certificate";
 
   certificate_request_state_ = CERTIFICATE_SUCCEEDED;
   SignalCertificateReady(certificate);
 
   transport_desc_factory_.set_certificate(certificate);
   transport_desc_factory_.set_secure(cricket::SEC_ENABLED);
 
   while (!create_session_description_requests_.empty()) {
     if (create_session_description_requests_.front().type ==
         CreateSessionDescriptionRequest::kOffer) {
       InternalCreateOffer(create_session_description_requests_.front());
     } else {
       InternalCreateAnswer(create_session_description_requests_.front());
     }
     create_session_description_requests_.pop();
   }
 }
 }  // namespace webrtc