Replace ASSERT by RTC_DCHECK in all non-test code.

webrtc/base/natsocketfactory.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 "webrtc/base/natsocketfactory.h"
 
 #include "webrtc/base/arraysize.h"
+#include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/natserver.h"
 #include "webrtc/base/virtualsocketserver.h"
 
 namespace rtc {
 
 // Packs the given socketaddress into the buffer in buf, in the quasi-STUN
 // format that the natserver uses.
 // Returns 0 if an invalid address is passed.
 size_t PackAddressForNAT(char* buf, size_t buf_size,
                          const SocketAddress& remote_addr) {
   const IPAddress& ip = remote_addr.ipaddr();
   int family = ip.family();
   buf[0] = 0;
   buf[1] = family;
   // Writes the port.
   *(reinterpret_cast<uint16_t*>(&buf[2])) = HostToNetwork16(remote_addr.port());
   if (family == AF_INET) {
-    ASSERT(buf_size >= kNATEncodedIPv4AddressSize);
+    RTC_DCHECK(buf_size >= kNATEncodedIPv4AddressSize);
     in_addr v4addr = ip.ipv4_address();
     memcpy(&buf[4], &v4addr, kNATEncodedIPv4AddressSize - 4);
     return kNATEncodedIPv4AddressSize;
   } else if (family == AF_INET6) {
-    ASSERT(buf_size >= kNATEncodedIPv6AddressSize);
+    RTC_DCHECK(buf_size >= kNATEncodedIPv6AddressSize);
     in6_addr v6addr = ip.ipv6_address();
     memcpy(&buf[4], &v6addr, kNATEncodedIPv6AddressSize - 4);
     return kNATEncodedIPv6AddressSize;
   }
   return 0U;
 }
 
 // Decodes the remote address from a packet that has been encoded with the nat's
 // quasi-STUN format. Returns the length of the address (i.e., the offset into
 // data where the original packet starts).
 size_t UnpackAddressFromNAT(const char* buf, size_t buf_size,
                             SocketAddress* remote_addr) {
-  ASSERT(buf_size >= 8);
-  ASSERT(buf[0] == 0);
+  RTC_DCHECK(buf_size >= 8);
+  RTC_DCHECK(buf[0] == 0);
   int family = buf[1];
   uint16_t port =
       NetworkToHost16(*(reinterpret_cast<const uint16_t*>(&buf[2])));
   if (family == AF_INET) {
     const in_addr* v4addr = reinterpret_cast<const in_addr*>(&buf[4]);
     *remote_addr = SocketAddress(IPAddress(*v4addr), port);
     return kNATEncodedIPv4AddressSize;
   } else if (family == AF_INET6) {
-    ASSERT(buf_size >= 20);
+    RTC_DCHECK(buf_size >= 20);
     const in6_addr* v6addr = reinterpret_cast<const in6_addr*>(&buf[4]);
     *remote_addr = SocketAddress(IPAddress(*v6addr), port);
     return kNATEncodedIPv6AddressSize;
   }
   return 0U;
 }
 
 
 // NATSocket
 class NATSocket : public AsyncSocket, public sigslot::has_slots<> {
@@ skipping 51 matching lines @@
     }
 
     if (result >= 0) {
       remote_addr_ = addr;
     }
 
     return result;
   }
 
   int Send(const void* data, size_t size) override {
-    ASSERT(connected_);
+    RTC_DCHECK(connected_);
     return SendTo(data, size, remote_addr_);
   }
 
   int SendTo(const void* data,
              size_t size,
              const SocketAddress& addr) override {
-    ASSERT(!connected_ || addr == remote_addr_);
+    RTC_DCHECK(!connected_ || addr == remote_addr_);
     if (server_addr_.IsNil() || type_ == SOCK_STREAM) {
       return socket_->SendTo(data, size, addr);
     }
     // This array will be too large for IPv4 packets, but only by 12 bytes.
     std::unique_ptr<char[]> buf(new char[size + kNATEncodedIPv6AddressSize]);
     size_t addrlength = PackAddressForNAT(buf.get(),
                                           size + kNATEncodedIPv6AddressSize,
                                           addr);
     size_t encoded_size = size + addrlength;
     memcpy(buf.get() + addrlength, data, size);
     int result = socket_->SendTo(buf.get(), encoded_size, server_addr_);
     if (result >= 0) {
-      ASSERT(result == static_cast<int>(encoded_size));
+      RTC_DCHECK(result == static_cast<int>(encoded_size));
       result = result - static_cast<int>(addrlength);
     }
     return result;
   }
 
   int Recv(void* data, size_t size, int64_t* timestamp) override {
     SocketAddress addr;
     return RecvFrom(data, size, &addr, timestamp);
   }
 
   int RecvFrom(void* data,
                size_t size,
                SocketAddress* out_addr,
                int64_t* timestamp) override {
     if (server_addr_.IsNil() || type_ == SOCK_STREAM) {
       return socket_->RecvFrom(data, size, out_addr, timestamp);
     }
     // Make sure we have enough room to read the requested amount plus the
     // largest possible header address.
     SocketAddress remote_addr;
     Grow(size + kNATEncodedIPv6AddressSize);
 
     // Read the packet from the socket.
     int result = socket_->RecvFrom(buf_, size_, &remote_addr, timestamp);
     if (result >= 0) {
-      ASSERT(remote_addr == server_addr_);
+      RTC_DCHECK(remote_addr == server_addr_);
 
       // TODO: we need better framing so we know how many bytes we can
       // return before we need to read the next address. For UDP, this will be
       // fine as long as the reader always reads everything in the packet.
-      ASSERT((size_t)result < size_);
+      RTC_DCHECK((size_t)result < size_);
 
       // Decode the wire packet into the actual results.
       SocketAddress real_remote_addr;
       size_t addrlength = UnpackAddressFromNAT(buf_, result, &real_remote_addr);
       memcpy(data, buf_ + addrlength, result - addrlength);
 
       // Make sure this packet should be delivered before returning it.
       if (!connected_ || (real_remote_addr == remote_addr_)) {
         if (out_addr)
           *out_addr = real_remote_addr;
@@ skipping 34 matching lines @@
   int EstimateMTU(uint16_t* mtu) override { return socket_->EstimateMTU(mtu); }
   int GetOption(Option opt, int* value) override {
     return socket_->GetOption(opt, value);
   }
   int SetOption(Option opt, int value) override {
     return socket_->SetOption(opt, value);
   }
 
   void OnConnectEvent(AsyncSocket* socket) {
     // If we're NATed, we need to send a message with the real addr to use.
-    ASSERT(socket == socket_);
+    RTC_DCHECK(socket == socket_);
     if (server_addr_.IsNil()) {
       connected_ = true;
       SignalConnectEvent(this);
     } else {
       SendConnectRequest();
     }
   }
   void OnReadEvent(AsyncSocket* socket) {
     // If we're NATed, we need to process the connect reply.
-    ASSERT(socket == socket_);
+    RTC_DCHECK(socket == socket_);
     if (type_ == SOCK_STREAM && !server_addr_.IsNil() && !connected_) {
       HandleConnectReply();
     } else {
       SignalReadEvent(this);
     }
   }
   void OnWriteEvent(AsyncSocket* socket) {
-    ASSERT(socket == socket_);
+    RTC_DCHECK(socket == socket_);
     SignalWriteEvent(this);
   }
   void OnCloseEvent(AsyncSocket* socket, int error) {
-    ASSERT(socket == socket_);
+    RTC_DCHECK(socket == socket_);
     SignalCloseEvent(this, error);
   }
 
  private:
   // Makes sure the buffer is at least the given size.
   void Grow(size_t new_size) {
     if (size_ < new_size) {
       delete[] buf_;
       size_ = new_size;
       buf_ = new char[size_];
@@ skipping 226 matching lines @@
 NATSocketServer::Translator* NATSocketServer::TranslatorMap::FindClient(
     const SocketAddress& int_ip) {
   Translator* nat = NULL;
   for (TranslatorMap::iterator it = begin(); it != end() && !nat; ++it) {
     nat = it->second->FindClient(int_ip);
   }
   return nat;
 }
 
 }  // namespace rtc