Replace ASSERT by RTC_DCHECK in all non-test code.

webrtc/p2p/base/stunport.cc

 /*
  *  Copyright 2004 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 196 matching lines @@
       error_(0),
       ready_(false),
       stun_keepalive_delay_(KEEPALIVE_DELAY),
       emit_local_for_anyaddress_(emit_local_for_anyaddress) {
   requests_.set_origin(origin);
 }
 
 bool UDPPort::Init() {
   stun_keepalive_lifetime_ = GetStunKeepaliveLifetime();
   if (!SharedSocket()) {
-    ASSERT(socket_ == NULL);
+    RTC_DCHECK(socket_ == NULL);
     socket_ = socket_factory()->CreateUdpSocket(
         rtc::SocketAddress(ip(), 0), min_port(), max_port());
     if (!socket_) {
       LOG_J(LS_WARNING, this) << "UDP socket creation failed";
       return false;
     }
     socket_->SignalReadPacket.connect(this, &UDPPort::OnReadPacket);
   }
   socket_->SignalSentPacket.connect(this, &UDPPort::OnSentPacket);
   socket_->SignalReadyToSend.connect(this, &UDPPort::OnReadyToSend);
   socket_->SignalAddressReady.connect(this, &UDPPort::OnLocalAddressReady);
   requests_.SignalSendPacket.connect(this, &UDPPort::OnSendPacket);
   return true;
 }
 
 UDPPort::~UDPPort() {
   if (!SharedSocket())
     delete socket_;
 }
 
 void UDPPort::PrepareAddress() {
-  ASSERT(requests_.empty());
+  RTC_DCHECK(requests_.empty());
   if (socket_->GetState() == rtc::AsyncPacketSocket::STATE_BOUND) {
     OnLocalAddressReady(socket_, socket_->GetLocalAddress());
   }
 }
 
 void UDPPort::MaybePrepareStunCandidate() {
   // Sending binding request to the STUN server if address is available to
   // prepare STUN candidate.
   if (!server_addresses_.empty()) {
     SendStunBindingRequests();
@@ skipping 68 matching lines @@
   AddAddress(addr, addr, rtc::SocketAddress(), UDP_PROTOCOL_NAME, "", "",
              LOCAL_PORT_TYPE, ICE_TYPE_PREFERENCE_HOST, 0, false);
   MaybePrepareStunCandidate();
 }
 
 void UDPPort::OnReadPacket(rtc::AsyncPacketSocket* socket,
                            const char* data,
                            size_t size,
                            const rtc::SocketAddress& remote_addr,
                            const rtc::PacketTime& packet_time) {
-  ASSERT(socket == socket_);
-  ASSERT(!remote_addr.IsUnresolvedIP());
+  RTC_DCHECK(socket == socket_);
+  RTC_DCHECK(!remote_addr.IsUnresolvedIP());
 
   // Look for a response from the STUN server.
   // Even if the response doesn't match one of our outstanding requests, we
   // will eat it because it might be a response to a retransmitted packet, and
   // we already cleared the request when we got the first response.
   if (server_addresses_.find(remote_addr) != server_addresses_.end()) {
     requests_.CheckResponse(data, size);
     return;
   }
 
   if (Connection* conn = GetConnection(remote_addr)) {
     conn->OnReadPacket(data, size, packet_time);
   } else {
     Port::OnReadPacket(data, size, remote_addr, PROTO_UDP);
   }
 }
 
 void UDPPort::OnSentPacket(rtc::AsyncPacketSocket* socket,
                            const rtc::SentPacket& sent_packet) {
   PortInterface::SignalSentPacket(sent_packet);
 }
 
 void UDPPort::OnReadyToSend(rtc::AsyncPacketSocket* socket) {
   Port::OnReadyToSend();
 }
 
 void UDPPort::SendStunBindingRequests() {
   // We will keep pinging the stun server to make sure our NAT pin-hole stays
   // open until the deadline (specified in SendStunBindingRequest).
-  ASSERT(requests_.empty());
+  RTC_DCHECK(requests_.empty());
 
   for (ServerAddresses::const_iterator it = server_addresses_.begin();
        it != server_addresses_.end(); ++it) {
     SendStunBindingRequest(*it);
   }
 }
 
 void UDPPort::ResolveStunAddress(const rtc::SocketAddress& stun_addr) {
   if (!resolver_) {
     resolver_.reset(new AddressResolver(socket_factory()));
     resolver_->SignalDone.connect(this, &UDPPort::OnResolveResult);
   }
 
   LOG_J(LS_INFO, this) << "Starting STUN host lookup for "
                        << stun_addr.ToSensitiveString();
   resolver_->Resolve(stun_addr);
 }
 
 void UDPPort::OnResolveResult(const rtc::SocketAddress& input,
                               int error) {
-  ASSERT(resolver_.get() != NULL);
+  RTC_DCHECK(resolver_.get() != NULL);
 
   rtc::SocketAddress resolved;
   if (error != 0 ||
       !resolver_->GetResolvedAddress(input, ip().family(), &resolved))  {
     LOG_J(LS_WARNING, this) << "StunPort: stun host lookup received error "
                             << error;
     OnStunBindingOrResolveRequestFailed(input);
     return;
   }
 
@@ skipping 117 matching lines @@
   const std::vector<Candidate>& existing_candidates = Candidates();
   std::vector<Candidate>::const_iterator it = existing_candidates.begin();
   for (; it != existing_candidates.end(); ++it) {
     if (it->address() == addr)
       return true;
   }
   return false;
 }
 
 }  // namespace cricket