Replace ASSERT by RTC_DCHECK in all non-test code.

webrtc/base/natserver.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.
  */
 
 #include <memory>
 
+#include "webrtc/base/checks.h"
 #include "webrtc/base/natsocketfactory.h"
 #include "webrtc/base/natserver.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/socketadapters.h"
 
 namespace rtc {
 
 RouteCmp::RouteCmp(NAT* nat) : symmetric(nat->IsSymmetric()) {
 }
 
@@ skipping 57 matching lines @@
     BufferedReadAdapter::DirectSend(&code, sizeof(char));
   }
 
  protected:
   void ProcessInput(char* data, size_t* len) override {
     if (*len < 2) {
       return;
     }
 
     int family = data[1];
-    ASSERT(family == AF_INET || family == AF_INET6);
+    RTC_DCHECK(family == AF_INET || family == AF_INET6);
     if ((family == AF_INET && *len < kNATEncodedIPv4AddressSize) ||
         (family == AF_INET6 && *len < kNATEncodedIPv6AddressSize)) {
       return;
     }
 
     SocketAddress dest_addr;
     size_t address_length = UnpackAddressFromNAT(data, *len, &dest_addr);
 
     *len -= address_length;
     if (*len > 0) {
@@ skipping 61 matching lines @@
   SocketAddress dest_addr;
   size_t length = UnpackAddressFromNAT(buf, size, &dest_addr);
 
   // Find the translation for these addresses (allocating one if necessary).
   SocketAddressPair route(addr, dest_addr);
   InternalMap::iterator iter = int_map_->find(route);
   if (iter == int_map_->end()) {
     Translate(route);
     iter = int_map_->find(route);
   }
-  ASSERT(iter != int_map_->end());
+  RTC_DCHECK(iter != int_map_->end());
 
   // Allow the destination to send packets back to the source.
   iter->second->WhitelistInsert(dest_addr);
 
   // Send the packet to its intended destination.
   rtc::PacketOptions options;
   iter->second->socket->SendTo(buf + length, size - length, dest_addr, options);
 }
 
 void NATServer::OnExternalUDPPacket(
     AsyncPacketSocket* socket, const char* buf, size_t size,
     const SocketAddress& remote_addr, const PacketTime& packet_time) {
   SocketAddress local_addr = socket->GetLocalAddress();
 
   // Find the translation for this addresses.
   ExternalMap::iterator iter = ext_map_->find(local_addr);
-  ASSERT(iter != ext_map_->end());
+  RTC_DCHECK(iter != ext_map_->end());
 
   // Allow the NAT to reject this packet.
   if (ShouldFilterOut(iter->second, remote_addr)) {
     LOG(LS_INFO) << "Packet from " << remote_addr.ToSensitiveString()
                  << " was filtered out by the NAT.";
     return;
   }
 
   // Forward this packet to the internal address.
   // First prepend the address in a quasi-STUN format.
@@ skipping 42 matching lines @@
   CritScope cs(&crit_);
   whitelist->insert(addr);
 }
 
 bool NATServer::TransEntry::WhitelistContains(const SocketAddress& ext_addr) {
   CritScope cs(&crit_);
   return whitelist->find(ext_addr) == whitelist->end();
 }
 
 }  // namespace rtc