Replace ASSERT by RTC_DCHECK in all non-test code.

webrtc/p2p/base/relayserver.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 83 matching lines @@
   for (size_t i = 0; i < removed_sockets_.size(); ++i)
     delete removed_sockets_[i];
   while (!server_sockets_.empty()) {
     rtc::AsyncSocket* socket = server_sockets_.begin()->first;
     server_sockets_.erase(server_sockets_.begin()->first);
     delete socket;
   }
 }
 
 void RelayServer::AddInternalSocket(rtc::AsyncPacketSocket* socket) {
-  ASSERT(internal_sockets_.end() ==
-      std::find(internal_sockets_.begin(), internal_sockets_.end(), socket));
+  RTC_DCHECK(internal_sockets_.end() == std::find(internal_sockets_.begin(),
+                                                  internal_sockets_.end(),
+                                                  socket));
   internal_sockets_.push_back(socket);
   socket->SignalReadPacket.connect(this, &RelayServer::OnInternalPacket);
 }
 
 void RelayServer::RemoveInternalSocket(rtc::AsyncPacketSocket* socket) {
   SocketList::iterator iter =
       std::find(internal_sockets_.begin(), internal_sockets_.end(), socket);
-  ASSERT(iter != internal_sockets_.end());
+  RTC_DCHECK(iter != internal_sockets_.end());
   internal_sockets_.erase(iter);
   removed_sockets_.push_back(socket);
   socket->SignalReadPacket.disconnect(this);
 }
 
 void RelayServer::AddExternalSocket(rtc::AsyncPacketSocket* socket) {
-  ASSERT(external_sockets_.end() ==
-      std::find(external_sockets_.begin(), external_sockets_.end(), socket));
+  RTC_DCHECK(external_sockets_.end() == std::find(external_sockets_.begin(),
+                                                  external_sockets_.end(),
+                                                  socket));
   external_sockets_.push_back(socket);
   socket->SignalReadPacket.connect(this, &RelayServer::OnExternalPacket);
 }
 
 void RelayServer::RemoveExternalSocket(rtc::AsyncPacketSocket* socket) {
   SocketList::iterator iter =
       std::find(external_sockets_.begin(), external_sockets_.end(), socket);
-  ASSERT(iter != external_sockets_.end());
+  RTC_DCHECK(iter != external_sockets_.end());
   external_sockets_.erase(iter);
   removed_sockets_.push_back(socket);
   socket->SignalReadPacket.disconnect(this);
 }
 
 void RelayServer::AddInternalServerSocket(rtc::AsyncSocket* socket,
                                           cricket::ProtocolType proto) {
-  ASSERT(server_sockets_.end() ==
-         server_sockets_.find(socket));
+  RTC_DCHECK(server_sockets_.end() == server_sockets_.find(socket));
   server_sockets_[socket] = proto;
   socket->SignalReadEvent.connect(this, &RelayServer::OnReadEvent);
 }
 
 void RelayServer::RemoveInternalServerSocket(
     rtc::AsyncSocket* socket) {
   ServerSocketMap::iterator iter = server_sockets_.find(socket);
-  ASSERT(iter != server_sockets_.end());
+  RTC_DCHECK(iter != server_sockets_.end());
   server_sockets_.erase(iter);
   socket->SignalReadEvent.disconnect(this);
 }
 
 int RelayServer::GetConnectionCount() const {
   return static_cast<int>(connections_.size());
 }
 
 rtc::SocketAddressPair RelayServer::GetConnection(int connection) const {
   int i = 0;
@@ skipping 11 matching lines @@
   for (ConnectionMap::const_iterator it = connections_.begin();
        it != connections_.end(); ++it) {
     if (it->second->addr_pair().destination() == address) {
       return true;
     }
   }
   return false;
 }
 
 void RelayServer::OnReadEvent(rtc::AsyncSocket* socket) {
-  ASSERT(server_sockets_.find(socket) != server_sockets_.end());
+  RTC_DCHECK(server_sockets_.find(socket) != server_sockets_.end());
   AcceptConnection(socket);
 }
 
 void RelayServer::OnInternalPacket(
     rtc::AsyncPacketSocket* socket, const char* bytes, size_t size,
     const rtc::SocketAddress& remote_addr,
     const rtc::PacketTime& packet_time) {
 
   // Get the address of the connection we just received on.
   rtc::SocketAddressPair ap(remote_addr, socket->GetLocalAddress());
-  ASSERT(!ap.destination().IsNil());
+  RTC_DCHECK(!ap.destination().IsNil());
 
   // If this did not come from an existing connection, it should be a STUN
   // allocate request.
   ConnectionMap::iterator piter = connections_.find(ap);
   if (piter == connections_.end()) {
     HandleStunAllocate(bytes, size, ap, socket);
     return;
   }
 
   RelayServerConnection* int_conn = piter->second;
@@ skipping 24 matching lines @@
   }
 }
 
 void RelayServer::OnExternalPacket(
     rtc::AsyncPacketSocket* socket, const char* bytes, size_t size,
     const rtc::SocketAddress& remote_addr,
     const rtc::PacketTime& packet_time) {
 
   // Get the address of the connection we just received on.
   rtc::SocketAddressPair ap(remote_addr, socket->GetLocalAddress());
-  ASSERT(!ap.destination().IsNil());
+  RTC_DCHECK(!ap.destination().IsNil());
 
   // If this connection already exists, then forward the traffic.
   ConnectionMap::iterator piter = connections_.find(ap);
   if (piter != connections_.end()) {
     // TODO: Check the HMAC.
     RelayServerConnection* ext_conn = piter->second;
     RelayServerConnection* int_conn =
         ext_conn->binding()->GetInternalConnection(
             ext_conn->addr_pair().source());
-    ASSERT(int_conn != NULL);
+    RTC_DCHECK(int_conn != NULL);
     int_conn->Send(bytes, size, ext_conn->addr_pair().source());
     ext_conn->Lock();  // allow outgoing packets
     return;
   }
 
   // The first packet should always be a STUN / TURN packet.  If it isn't, then
   // we should just ignore this packet.
   RelayMessage msg;
   rtc::ByteBufferReader buf(bytes, size);
   if (!msg.Read(&buf)) {
@@ skipping 27 matching lines @@
   ext_conn->binding()->AddExternalConnection(ext_conn);
   AddConnection(ext_conn);
 
   // We always know where external packets should be forwarded, so we can lock
   // them from the beginning.
   ext_conn->Lock();
 
   // Send this message on the appropriate internal connection.
   RelayServerConnection* int_conn = ext_conn->binding()->GetInternalConnection(
       ext_conn->addr_pair().source());
-  ASSERT(int_conn != NULL);
+  RTC_DCHECK(int_conn != NULL);
   int_conn->Send(bytes, size, ext_conn->addr_pair().source());
 }
 
 bool RelayServer::HandleStun(
     const char* bytes, size_t size, const rtc::SocketAddress& remote_addr,
     rtc::AsyncPacketSocket* socket, std::string* username,
     StunMessage* msg) {
 
   // Parse this into a stun message. Eat the message if this fails.
   rtc::ByteBufferReader buf(bytes, size);
@@ skipping 161 matching lines @@
   if (!data_attr) {
     int_conn->SendStunError(request, 400, "Bad Request");
     return;
   }
 
   rtc::SocketAddress ext_addr(addr_attr->ipaddr(), addr_attr->port());
   RelayServerConnection* ext_conn =
       int_conn->binding()->GetExternalConnection(ext_addr);
   if (!ext_conn) {
     // Create a new connection to establish the relationship with this binding.
-    ASSERT(external_sockets_.size() == 1);
+    RTC_DCHECK(external_sockets_.size() == 1);
     rtc::AsyncPacketSocket* socket = external_sockets_[0];
     rtc::SocketAddressPair ap(ext_addr, socket->GetLocalAddress());
     ext_conn = new RelayServerConnection(int_conn->binding(), ap, socket);
     ext_conn->binding()->AddExternalConnection(ext_conn);
     AddConnection(ext_conn);
   }
 
   // If this connection has pinged us, then allow outgoing traffic.
   if (ext_conn->locked())
     ext_conn->Send(data_attr->bytes(), data_attr->length());
@@ skipping 17 matching lines @@
     StunUInt32Attribute* options2_attr =
       StunAttribute::CreateUInt32(cricket::STUN_ATTR_OPTIONS);
     options2_attr->SetValue(0x01);
     response.AddAttribute(options2_attr);
 
     int_conn->SendStun(response);
   }
 }
 
 void RelayServer::AddConnection(RelayServerConnection* conn) {
-  ASSERT(connections_.find(conn->addr_pair()) == connections_.end());
+  RTC_DCHECK(connections_.find(conn->addr_pair()) == connections_.end());
   connections_[conn->addr_pair()] = conn;
 }
 
 void RelayServer::RemoveConnection(RelayServerConnection* conn) {
   ConnectionMap::iterator iter = connections_.find(conn->addr_pair());
-  ASSERT(iter != connections_.end());
+  RTC_DCHECK(iter != connections_.end());
   connections_.erase(iter);
 }
 
 void RelayServer::RemoveBinding(RelayServerBinding* binding) {
   BindingMap::iterator iter = bindings_.find(binding->username());
-  ASSERT(iter != bindings_.end());
+  RTC_DCHECK(iter != bindings_.end());
   bindings_.erase(iter);
 
   if (log_bindings_) {
     LOG(LS_INFO) << "Removed binding " << binding->username() << ", "
                  << bindings_.size() << " remaining";
   }
 }
 
 void RelayServer::OnMessage(rtc::Message *pmsg) {
-#if ENABLE_DEBUG
   static const uint32_t kMessageAcceptConnection = 1;
-  ASSERT(pmsg->message_id == kMessageAcceptConnection);
-#endif
+  RTC_DCHECK(pmsg->message_id == kMessageAcceptConnection);
+
   rtc::MessageData* data = pmsg->pdata;
   rtc::AsyncSocket* socket =
       static_cast <rtc::TypedMessageData<rtc::AsyncSocket*>*>
       (data)->data();
   AcceptConnection(socket);
   delete data;
 }
 
 void RelayServer::OnTimeout(RelayServerBinding* binding) {
   // This call will result in all of the necessary clean-up. We can't call
   // delete here, because you can't delete an object that is signaling you.
   thread_->Dispose(binding);
 }
 
 void RelayServer::AcceptConnection(rtc::AsyncSocket* server_socket) {
   // Check if someone is trying to connect to us.
   rtc::SocketAddress accept_addr;
   rtc::AsyncSocket* accepted_socket =
       server_socket->Accept(&accept_addr);
   if (accepted_socket != NULL) {
     // We had someone trying to connect, now check which protocol to
     // use and create a packet socket.
-    ASSERT(server_sockets_[server_socket] == cricket::PROTO_TCP ||
-           server_sockets_[server_socket] == cricket::PROTO_SSLTCP);
+    RTC_DCHECK(server_sockets_[server_socket] == cricket::PROTO_TCP ||
+               server_sockets_[server_socket] == cricket::PROTO_SSLTCP);
     if (server_sockets_[server_socket] == cricket::PROTO_SSLTCP) {
       accepted_socket = new rtc::AsyncSSLServerSocket(accepted_socket);
     }
     rtc::AsyncTCPSocket* tcp_socket =
         new rtc::AsyncTCPSocket(accepted_socket, false);
 
     // Finally add the socket so it can start communicating with the client.
     AddInternalSocket(tcp_socket);
   }
 }
@@ skipping 38 matching lines @@
   msg.AddAttribute(magic_cookie_attr);
 
   StunAddressAttribute* addr_attr =
       StunAttribute::CreateAddress(STUN_ATTR_SOURCE_ADDRESS2);
   addr_attr->SetIP(from_addr.ipaddr());
   addr_attr->SetPort(from_addr.port());
   msg.AddAttribute(addr_attr);
 
   StunByteStringAttribute* data_attr =
       StunAttribute::CreateByteString(STUN_ATTR_DATA);
-  ASSERT(size <= 65536);
+  RTC_DCHECK(size <= 65536);
   data_attr->CopyBytes(data, uint16_t(size));
   msg.AddAttribute(data_attr);
 
   SendStun(msg);
 }
 
 void RelayServerConnection::SendStun(const StunMessage& msg) {
   // Note that the binding has been used again.
   binding_->NoteUsed();
 
@@ skipping 80 matching lines @@
     const rtc::SocketAddress& ext_addr) {
 
   // Look for an internal connection that is locked to this address.
   for (size_t i = 0; i < internal_connections_.size(); ++i) {
     if (internal_connections_[i]->locked() &&
         (ext_addr == internal_connections_[i]->default_destination()))
       return internal_connections_[i];
   }
 
   // If one was not found, we send to the first connection.
-  ASSERT(internal_connections_.size() > 0);
+  RTC_DCHECK(internal_connections_.size() > 0);
   return internal_connections_[0];
 }
 
 RelayServerConnection* RelayServerBinding::GetExternalConnection(
     const rtc::SocketAddress& ext_addr) {
   for (size_t i = 0; i < external_connections_.size(); ++i) {
     if (ext_addr == external_connections_[i]->addr_pair().source())
       return external_connections_[i];
   }
   return 0;
 }
 
 void RelayServerBinding::OnMessage(rtc::Message *pmsg) {
   if (pmsg->message_id == MSG_LIFETIME_TIMER) {
-    ASSERT(!pmsg->pdata);
+    RTC_DCHECK(!pmsg->pdata);
 
     // If the lifetime timeout has been exceeded, then send a signal.
     // Otherwise, just keep waiting.
     if (rtc::TimeMillis() >= last_used_ + lifetime_) {
       LOG(LS_INFO) << "Expiring binding " << username_;
       SignalTimeout(this);
     } else {
       server_->thread()->PostDelayed(RTC_FROM_HERE, lifetime_, this,
                                      MSG_LIFETIME_TIMER);
     }
 
   } else {
     RTC_NOTREACHED();
   }
 }
 
 }  // namespace cricket