Replace ASSERT by RTC_DCHECK in all non-test code.

webrtc/p2p/base/tcpport.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 49 matching lines @@
  *  |Writable:  N|OnConnect  |Writable:  N|Completed |Writable:  Y|
  *  |PendingTCP:Y+---------> |PendingTCP:N+--------> |PendingTCP:N|
  *  |PretendWri:N|           |PretendWri:N|          |PretendWri:N|
  *  +------------+           +------------+          +------------+
  *
  */
 
 #include "webrtc/p2p/base/tcpport.h"
 
 #include "webrtc/p2p/base/common.h"
+#include "webrtc/base/checks.h"
 #include "webrtc/base/common.h"
 #include "webrtc/base/logging.h"
 
 namespace cricket {
 
 TCPPort::TCPPort(rtc::Thread* thread,
                  rtc::PacketSocketFactory* factory,
                  rtc::Network* network,
                  const rtc::IPAddress& ip,
                  uint16_t min_port,
@@ skipping 164 matching lines @@
     return SOCKET_ERROR;
   }
 }
 
 int TCPPort::GetError() {
   return error_;
 }
 
 void TCPPort::OnNewConnection(rtc::AsyncPacketSocket* socket,
                               rtc::AsyncPacketSocket* new_socket) {
-  ASSERT(socket == socket_);
+  RTC_DCHECK(socket == socket_);
 
   Incoming incoming;
   incoming.addr = new_socket->GetRemoteAddress();
   incoming.socket = new_socket;
   incoming.socket->SignalReadPacket.connect(this, &TCPPort::OnReadPacket);
   incoming.socket->SignalReadyToSend.connect(this, &TCPPort::OnReadyToSend);
   incoming.socket->SignalSentPacket.connect(this, &TCPPort::OnSentPacket);
 
   LOG_J(LS_VERBOSE, this) << "Accepted connection from "
                           << incoming.addr.ToSensitiveString();
@@ skipping 48 matching lines @@
       connection_pending_(false),
       pretending_to_be_writable_(false),
       reconnection_timeout_(cricket::CONNECTION_WRITE_CONNECT_TIMEOUT) {
   if (outgoing_) {
     CreateOutgoingTcpSocket();
   } else {
     // Incoming connections should match the network address.
     LOG_J(LS_VERBOSE, this)
         << "socket ipaddr: " << socket_->GetLocalAddress().ToString()
         << ",port() ip:" << port->ip().ToString();
-    ASSERT(socket_->GetLocalAddress().ipaddr() == port->ip());
+    RTC_DCHECK(socket_->GetLocalAddress().ipaddr() == port->ip());
     ConnectSocketSignals(socket);
   }
 }
 
 TCPConnection::~TCPConnection() {
 }
 
 int TCPConnection::Send(const void* data, size_t size,
                         const rtc::PacketOptions& options) {
   if (!socket_) {
@@ skipping 37 matching lines @@
   // Process the STUN response before we inform upper layer ready to send.
   Connection::OnConnectionRequestResponse(req, response);
 
   // If we're in the state of pretending to be writeable, we should inform the
   // upper layer it's ready to send again as previous EWOULDLBLOCK from socket
   // would have stopped the outgoing stream.
   if (pretending_to_be_writable_) {
     Connection::OnReadyToSend();
   }
   pretending_to_be_writable_ = false;
-  ASSERT(write_state() == STATE_WRITABLE);
+  RTC_DCHECK(write_state() == STATE_WRITABLE);
 }
 
 void TCPConnection::OnConnect(rtc::AsyncPacketSocket* socket) {
-  ASSERT(socket == socket_.get());
+  RTC_DCHECK(socket == socket_.get());
   // Do not use this connection if the socket bound to a different address than
   // the one we asked for. This is seen in Chrome, where TCP sockets cannot be
   // given a binding address, and the platform is expected to pick the
   // correct local address.
   const rtc::SocketAddress& socket_addr = socket->GetLocalAddress();
   if (socket_addr.ipaddr() == port()->ip()) {
     LOG_J(LS_VERBOSE, this) << "Connection established to "
                             << socket->GetRemoteAddress().ToSensitiveString();
   } else if (IPIsAny(port()->ip())) {
     LOG(LS_WARNING) << "Socket is bound to a different address:"
@@ skipping 16 matching lines @@
     OnClose(socket, 0);
     return;
   }
 
   // Connection is established successfully.
   set_connected(true);
   connection_pending_ = false;
 }
 
 void TCPConnection::OnClose(rtc::AsyncPacketSocket* socket, int error) {
-  ASSERT(socket == socket_.get());
+  RTC_DCHECK(socket == socket_.get());
   LOG_J(LS_INFO, this) << "Connection closed with error " << error;
 
   // Guard against the condition where IPC socket will call OnClose for every
   // packet it can't send.
   if (connected()) {
     set_connected(false);
 
     // Prevent the connection from being destroyed by redundant SignalClose
     // events.
     pretending_to_be_writable_ = true;
@@ skipping 38 matching lines @@
                        << "trying to reconnect";
 
   CreateOutgoingTcpSocket();
   error_ = EPIPE;
 }
 
 void TCPConnection::OnReadPacket(
   rtc::AsyncPacketSocket* socket, const char* data, size_t size,
   const rtc::SocketAddress& remote_addr,
   const rtc::PacketTime& packet_time) {
-  ASSERT(socket == socket_.get());
+  RTC_DCHECK(socket == socket_.get());
   Connection::OnReadPacket(data, size, packet_time);
 }
 
 void TCPConnection::OnReadyToSend(rtc::AsyncPacketSocket* socket) {
-  ASSERT(socket == socket_.get());
+  RTC_DCHECK(socket == socket_.get());
   Connection::OnReadyToSend();
 }
 
 void TCPConnection::CreateOutgoingTcpSocket() {
-  ASSERT(outgoing_);
+  RTC_DCHECK(outgoing_);
   // TODO(guoweis): Handle failures here (unlikely since TCP).
   int opts = (remote_candidate().protocol() == SSLTCP_PROTOCOL_NAME)
                  ? rtc::PacketSocketFactory::OPT_TLS_FAKE
                  : 0;
   socket_.reset(port()->socket_factory()->CreateClientTcpSocket(
       rtc::SocketAddress(port()->ip(), 0), remote_candidate().address(),
       port()->proxy(), port()->user_agent(), opts));
   if (socket_) {
     LOG_J(LS_VERBOSE, this)
         << "Connecting from " << socket_->GetLocalAddress().ToSensitiveString()
@@ skipping 10 matching lines @@
 void TCPConnection::ConnectSocketSignals(rtc::AsyncPacketSocket* socket) {
   if (outgoing_) {
     socket->SignalConnect.connect(this, &TCPConnection::OnConnect);
   }
   socket->SignalReadPacket.connect(this, &TCPConnection::OnReadPacket);
   socket->SignalReadyToSend.connect(this, &TCPConnection::OnReadyToSend);
   socket->SignalClose.connect(this, &TCPConnection::OnClose);
 }
 
 }  // namespace cricket