Replace ASSERT by RTC_DCHECK in all non-test code.

webrtc/base/socketadapters.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 79 matching lines @@
 
   // Didn't read anything; return error from socket
   return res;
 }
 
 void BufferedReadAdapter::BufferInput(bool on) {
   buffering_ = on;
 }
 
 void BufferedReadAdapter::OnReadEvent(AsyncSocket * socket) {
-  ASSERT(socket == socket_);
+  RTC_DCHECK(socket == socket_);
 
   if (!buffering_) {
     AsyncSocketAdapter::OnReadEvent(socket);
     return;
   }
 
   if (data_len_ >= buffer_size_) {
     LOG(INFO) << "Input buffer overflow";
     RTC_NOTREACHED();
     data_len_ = 0;
@@ skipping 66 matching lines @@
 }
 
 int AsyncSSLSocket::Connect(const SocketAddress& addr) {
   // Begin buffering before we connect, so that there isn't a race condition
   // between potential senders and receiving the OnConnectEvent signal
   BufferInput(true);
   return BufferedReadAdapter::Connect(addr);
 }
 
 void AsyncSSLSocket::OnConnectEvent(AsyncSocket * socket) {
-  ASSERT(socket == socket_);
+  RTC_DCHECK(socket == socket_);
   // TODO: we could buffer output too...
   VERIFY(sizeof(kSslClientHello) ==
       DirectSend(kSslClientHello, sizeof(kSslClientHello)));
 }
 
 void AsyncSSLSocket::ProcessInput(char* data, size_t* len) {
   if (*len < sizeof(kSslServerHello))
     return;
 
   if (memcmp(kSslServerHello, data, sizeof(kSslServerHello)) != 0) {
@@ skipping 29 matching lines @@
 
   if (memcmp(kSslClientHello, data, sizeof(kSslClientHello)) != 0) {
     Close();
     SignalCloseEvent(this, 0);
     return;
   }
 
   *len -= sizeof(kSslClientHello);
 
   // Clients should not send more data until the handshake is completed.
-  ASSERT(*len == 0);
+  RTC_DCHECK(*len == 0);
 
   // Send a server hello back to the client.
   DirectSend(kSslServerHello, sizeof(kSslServerHello));
 
   // Handshake completed for us, redirect input to our parent.
   BufferInput(false);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ skipping 302 matching lines @@
   } else {
     return CS_CLOSED;
   }
 }
 
 void AsyncSocksProxySocket::OnConnectEvent(AsyncSocket* socket) {
   SendHello();
 }
 
 void AsyncSocksProxySocket::ProcessInput(char* data, size_t* len) {
-  ASSERT(state_ < SS_TUNNEL);
+  RTC_DCHECK(state_ < SS_TUNNEL);
 
   ByteBufferReader response(data, *len);
 
   if (state_ == SS_HELLO) {
     uint8_t ver, method;
     if (!response.ReadUInt8(&ver) ||
         !response.ReadUInt8(&method))
       return;
 
     if (ver != 5) {
@@ skipping 137 matching lines @@
   SignalCloseEvent(this, error);
 }
 
 AsyncSocksProxyServerSocket::AsyncSocksProxyServerSocket(AsyncSocket* socket)
     : AsyncProxyServerSocket(socket, kBufferSize), state_(SS_HELLO) {
   BufferInput(true);
 }
 
 void AsyncSocksProxyServerSocket::ProcessInput(char* data, size_t* len) {
   // TODO: See if the whole message has arrived
-  ASSERT(state_ < SS_CONNECT_PENDING);
+  RTC_DCHECK(state_ < SS_CONNECT_PENDING);
 
   ByteBufferReader response(data, *len);
   if (state_ == SS_HELLO) {
     HandleHello(&response);
   } else if (state_ == SS_AUTH) {
     HandleAuth(&response);
   } else if (state_ == SS_CONNECT) {
     HandleConnect(&response);
   }
 
@@ skipping 175 matching lines @@
 void LoggingSocketAdapter::OnCloseEvent(AsyncSocket * socket, int err) {
   LogMultiline(level_, label_.c_str(), false, NULL, 0, hex_mode_, &lms_);
   LogMultiline(level_, label_.c_str(), true, NULL, 0, hex_mode_, &lms_);
   LOG_V(level_) << label_ << " Closed with error: " << err;
   AsyncSocketAdapter::OnCloseEvent(socket, err);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 }  // namespace rtc