Replace ASSERT by RTC_DCHECK in all non-test code.

webrtc/p2p/base/relayport.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 <algorithm>
 
 #include "webrtc/p2p/base/relayport.h"
 #include "webrtc/base/asyncpacketsocket.h"
+#include "webrtc/base/checks.h"
 #include "webrtc/base/helpers.h"
 #include "webrtc/base/logging.h"
 
 namespace cricket {
 
 static const int kMessageConnectTimeout = 1;
 static const int kKeepAliveDelay           = 10 * 60 * 1000;
 static const int kRetryTimeout             = 50 * 1000;  // ICE says 50 secs
 // How long to wait for a socket to connect to remote host in milliseconds
 // before trying another connection.
@@ skipping 239 matching lines @@
   } else {
     return memcmp(data + 24,
                   TURN_MAGIC_COOKIE_VALUE,
                   sizeof(TURN_MAGIC_COOKIE_VALUE)) == 0;
   }
 }
 
 void RelayPort::PrepareAddress() {
   // We initiate a connect on the first entry.  If this completes, it will fill
   // in the server address as the address of this port.
-  ASSERT(entries_.size() == 1);
+  RTC_DCHECK(entries_.size() == 1);
   entries_[0]->Connect();
   ready_ = false;
 }
 
 Connection* RelayPort::CreateConnection(const Candidate& address,
                                         CandidateOrigin origin) {
   // We only create conns to non-udp sockets if they are incoming on this port
   if ((address.protocol() != UDP_PROTOCOL_NAME) &&
       (origin != ORIGIN_THIS_PORT)) {
     return 0;
@@ skipping 50 matching lines @@
       entry->SetServerIndex(entries_[0]->ServerIndex());
     }
     entry->Connect();
     entries_.push_back(entry);
   }
 
   // If the entry is connected, then we can send on it (though wrapping may
   // still be necessary).  Otherwise, we can't yet use this connection, so we
   // default to the first one.
   if (!entry || !entry->connected()) {
-    ASSERT(!entries_.empty());
+    RTC_DCHECK(!entries_.empty());
     entry = entries_[0];
     if (!entry->connected()) {
       error_ = ENOTCONN;
       return SOCKET_ERROR;
     }
   }
 
   // Send the actual contents to the server using the usual mechanism.
   int sent = entry->SendTo(data, size, addr, options);
   if (sent <= 0) {
-    ASSERT(sent < 0);
+    RTC_DCHECK(sent < 0);
     error_ = entry->GetError();
     return SOCKET_ERROR;
   }
   // The caller of the function is expecting the number of user data bytes,
   // rather than the size of the packet.
   return static_cast<int>(size);
 }
 
 int RelayPort::SetOption(rtc::Socket::Option opt, int value) {
   int result = 0;
@@ skipping 62 matching lines @@
 }
 
 void RelayConnection::OnSendPacket(const void* data, size_t size,
                                    StunRequest* req) {
   // TODO(mallinath) Find a way to get DSCP value from Port.
   rtc::PacketOptions options;  // Default dscp set to NO_CHANGE.
   int sent = socket_->SendTo(data, size, GetAddress(), options);
   if (sent <= 0) {
     LOG(LS_VERBOSE) << "OnSendPacket: failed sending to " << GetAddress() <<
         strerror(socket_->GetError());
-    ASSERT(sent < 0);
+    RTC_DCHECK(sent < 0);
   }
 }
 
 int RelayConnection::Send(const void* pv, size_t cb,
                           const rtc::PacketOptions& options) {
   return socket_->SendTo(pv, cb, GetAddress(), options);
 }
 
 void RelayConnection::SendAllocateRequest(RelayEntry* entry, int delay) {
   request_manager_->SendDelayed(new AllocateRequest(entry, this), delay);
@@ skipping 189 matching lines @@
     if (current_connection_)
       port()->SignalConnectFailure(current_connection_->protocol_address());
 
     // Try to connect to the next server address.
     server_index_ += 1;
     Connect();
   }
 }
 
 void RelayEntry::OnMessage(rtc::Message *pmsg) {
-  ASSERT(pmsg->message_id == kMessageConnectTimeout);
+  RTC_DCHECK(pmsg->message_id == kMessageConnectTimeout);
   if (current_connection_) {
     const ProtocolAddress* ra = current_connection_->protocol_address();
     LOG(LS_WARNING) << "Relay " << ra->proto << " connection to " <<
         ra->address << " timed out";
 
     // Currently we connect to each server address in sequence. If we
     // have more addresses to try, treat this is an error and move on to
     // the next address, otherwise give this connection more time and
     // await the real timeout.
     //
@@ skipping 18 matching lines @@
                                int error) {
   PLOG(LERROR, error) << "Relay connection failed: socket closed";
   HandleConnectFailure(socket);
 }
 
 void RelayEntry::OnReadPacket(
     rtc::AsyncPacketSocket* socket,
     const char* data, size_t size,
     const rtc::SocketAddress& remote_addr,
     const rtc::PacketTime& packet_time) {
-  // ASSERT(remote_addr == port_->server_addr());
+  // RTC_DCHECK(remote_addr == port_->server_addr());
   // TODO: are we worried about this?
 
   if (current_connection_ == NULL || socket != current_connection_->socket()) {
     // This packet comes from an unknown address.
     LOG(WARNING) << "Dropping packet: unknown address";
     return;
   }
 
   // If the magic cookie is not present, then this is an unwrapped packet sent
   // by the server,  The actual remote address is the one we recorded.
@@ skipping 140 matching lines @@
   if (rtc::TimeMillis() - start_time_ <= kRetryTimeout)
     entry_->ScheduleKeepAlive();
 }
 
 void AllocateRequest::OnTimeout() {
   LOG(INFO) << "Allocate request timed out";
   entry_->HandleConnectFailure(connection_->socket());
 }
 
 }  // namespace cricket