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

webrtc/p2p/stunprober/stunprober.cc

 /*
  *  Copyright 2015 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.
  */
 
@@ skipping 112 matching lines @@
     socket_->Close();
   }
   for (auto req : requests_) {
     if (req) {
       delete req;
     }
   }
 }
 
 void StunProber::Requester::SendStunRequest() {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   requests_.push_back(new Request());
   Request& request = *(requests_.back());
   cricket::StunMessage message;
 
   // Random transaction ID, STUN_BINDING_REQUEST
   message.SetTransactionID(
       rtc::CreateRandomString(cricket::kStunTransactionIdLength));
   message.SetType(cricket::STUN_BINDING_REQUEST);
 
   rtc::scoped_ptr<rtc::ByteBuffer> request_packet(
@@ skipping 13 matching lines @@
   int rv = socket_->SendTo(const_cast<char*>(request_packet->Data()),
                            request_packet->Length(), addr, options);
   if (rv < 0) {
     prober_->End(WRITE_FAILED);
     return;
   }
 
   request.sent_time_ms = rtc::Time();
 
   num_request_sent_++;
-  DCHECK(static_cast<size_t>(num_request_sent_) <= server_ips_.size());
+  RTC_DCHECK(static_cast<size_t>(num_request_sent_) <= server_ips_.size());
 }
 
 void StunProber::Requester::Request::ProcessResponse(const char* buf,
                                                      size_t buf_len) {
   int64 now = rtc::Time();
   rtc::ByteBuffer message(buf, buf_len);
   cricket::StunMessage stun_response;
   if (!stun_response.Read(&message)) {
     // Invalid or incomplete STUN packet.
     received_time_ms = 0;
@@ skipping 17 matching lines @@
 
   srflx_addr = addr_attr->GetAddress();
 }
 
 void StunProber::Requester::OnStunResponseReceived(
     rtc::AsyncPacketSocket* socket,
     const char* buf,
     size_t size,
     const rtc::SocketAddress& addr,
     const rtc::PacketTime& time) {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(socket_);
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
+  RTC_DCHECK(socket_);
   Request* request = GetRequestByAddress(addr.ipaddr());
   if (!request) {
     // Something is wrong, finish the test.
     prober_->End(GENERIC_FAILURE);
     return;
   }
 
   num_response_received_++;
   request->ProcessResponse(buf, size);
 }
 
 StunProber::Requester::Request* StunProber::Requester::GetRequestByAddress(
     const rtc::IPAddress& ipaddr) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   for (auto request : requests_) {
     if (request->server_addr == ipaddr) {
       return request;
     }
   }
 
   return nullptr;
 }
 
 StunProber::StunProber(rtc::PacketSocketFactory* socket_factory,
@@ skipping 17 matching lines @@
     }
   }
 }
 
 bool StunProber::Start(const std::vector<rtc::SocketAddress>& servers,
                        bool shared_socket_mode,
                        int interval_ms,
                        int num_request_per_ip,
                        int timeout_ms,
                        const AsyncCallback callback) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   interval_ms_ = interval_ms;
   shared_socket_mode_ = shared_socket_mode;
 
   requests_per_ip_ = num_request_per_ip;
   if (requests_per_ip_ == 0 || servers.size() == 0) {
     return false;
   }
 
   timeout_ms_ = timeout_ms;
   servers_ = servers;
@@ skipping 14 matching lines @@
 
 void StunProber::OnSocketReady(rtc::AsyncPacketSocket* socket,
                                const rtc::SocketAddress& addr) {
   total_ready_sockets_++;
   if (total_ready_sockets_ == total_socket_required()) {
     MaybeScheduleStunRequests();
   }
 }
 
 void StunProber::OnServerResolved(rtc::AsyncResolverInterface* resolver) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
 
   if (resolver->GetError() == 0) {
     rtc::SocketAddress addr(resolver->address().ipaddr(),
                             resolver->address().port());
     all_servers_addrs_.push_back(addr);
   }
 
   // Deletion of AsyncResolverInterface can't be done in OnResolveResult which
   // handles SignalDone.
   invoker_.AsyncInvoke<void>(
@@ skipping 32 matching lines @@
     if (socket->GetState() == rtc::AsyncPacketSocket::STATE_BINDING) {
       socket->SignalAddressReady.connect(this, &StunProber::OnSocketReady);
     } else {
       OnSocketReady(socket.get(), rtc::SocketAddress(INADDR_ANY, 0));
     }
     sockets_.push_back(socket.release());
   }
 }
 
 StunProber::Requester* StunProber::CreateRequester() {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   if (!sockets_.size()) {
     return nullptr;
   }
   StunProber::Requester* requester;
   if (shared_socket_mode_) {
     requester = new Requester(this, sockets_.back(), all_servers_addrs_);
   } else {
     std::vector<rtc::SocketAddress> server_ip;
     server_ip.push_back(
         all_servers_addrs_[(num_request_sent_ % all_servers_addrs_.size())]);
@@ skipping 11 matching lines @@
   }
   if (!current_requester_) {
     return false;
   }
   current_requester_->SendStunRequest();
   num_request_sent_++;
   return true;
 }
 
 void StunProber::MaybeScheduleStunRequests() {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   uint32 now = rtc::Time();
 
   if (Done()) {
     invoker_.AsyncInvokeDelayed<void>(
         thread_, rtc::Bind(&StunProber::End, this, SUCCESS), timeout_ms_);
     return;
   }
   if ((now + (thread_wake_up_interval_ms / 2)) >= next_request_time_ms_) {
     if (!SendNextRequest()) {
       End(GENERIC_FAILURE);
@@ skipping 64 matching lines @@
   // server reflexive IPs.
   if (srflx_ips.size() > 1) {
     return false;
   }
 
   int num_sent = 0;
   int num_received = 0;
   int num_server_ip_with_response = 0;
 
   for (const auto& kv : num_response_per_server) {
-    DCHECK_GT(kv.second, 0);
+    RTC_DCHECK_GT(kv.second, 0);
     num_server_ip_with_response++;
     num_received += kv.second;
     num_sent += num_request_per_server[kv.first];
   }
 
   // Not receiving any response, the trial is inconclusive.
   if (!num_received) {
     return false;
   }
 
@@ skipping 40 matching lines @@
 
   if (num_received) {
     stats.average_rtt_ms = static_cast<int>((rtt_sum / num_received));
   }
 
   *prob_stats = stats;
   return true;
 }
 
 void StunProber::End(StunProber::Status status) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  RTC_DCHECK(thread_checker_.CalledOnValidThread());
   if (!finished_callback_.empty()) {
     AsyncCallback callback = finished_callback_;
     finished_callback_ = AsyncCallback();
 
     // Callback at the last since the prober might be deleted in the callback.
     callback(this, status);
   }
 }
 
 }  // namespace stunprober