Replace ASSERT by RTC_DCHECK in all non-test code.

webrtc/p2p/base/turnserver.cc

 /*
  *  Copyright 2012 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/p2p/base/turnserver.h"
 
 #include <tuple>  // for std::tie
 
 #include "webrtc/p2p/base/asyncstuntcpsocket.h"
 #include "webrtc/p2p/base/common.h"
 #include "webrtc/p2p/base/packetsocketfactory.h"
 #include "webrtc/p2p/base/stun.h"
 #include "webrtc/base/bind.h"
 #include "webrtc/base/bytebuffer.h"
+#include "webrtc/base/checks.h"
 #include "webrtc/base/helpers.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/messagedigest.h"
 #include "webrtc/base/socketadapters.h"
 #include "webrtc/base/stringencode.h"
 #include "webrtc/base/thread.h"
 
 namespace cricket {
 
 // TODO(juberti): Move this all to a future turnmessage.h
@@ skipping 104 matching lines @@
 
   for (ServerSocketMap::iterator it = server_listen_sockets_.begin();
        it != server_listen_sockets_.end(); ++it) {
     rtc::AsyncSocket* socket = it->first;
     delete socket;
   }
 }
 
 void TurnServer::AddInternalSocket(rtc::AsyncPacketSocket* socket,
                                    ProtocolType proto) {
-  ASSERT(server_sockets_.end() == server_sockets_.find(socket));
+  RTC_DCHECK(server_sockets_.end() == server_sockets_.find(socket));
   server_sockets_[socket] = proto;
   socket->SignalReadPacket.connect(this, &TurnServer::OnInternalPacket);
 }
 
 void TurnServer::AddInternalServerSocket(rtc::AsyncSocket* socket,
                                          ProtocolType proto) {
-  ASSERT(server_listen_sockets_.end() ==
-      server_listen_sockets_.find(socket));
+  RTC_DCHECK(server_listen_sockets_.end() ==
+             server_listen_sockets_.find(socket));
   server_listen_sockets_[socket] = proto;
   socket->SignalReadEvent.connect(this, &TurnServer::OnNewInternalConnection);
 }
 
 void TurnServer::SetExternalSocketFactory(
     rtc::PacketSocketFactory* factory,
     const rtc::SocketAddress& external_addr) {
   external_socket_factory_.reset(factory);
   external_addr_ = external_addr;
 }
 
 void TurnServer::OnNewInternalConnection(rtc::AsyncSocket* socket) {
-  ASSERT(server_listen_sockets_.find(socket) != server_listen_sockets_.end());
+  RTC_DCHECK(server_listen_sockets_.find(socket) !=
+             server_listen_sockets_.end());
   AcceptConnection(socket);
 }
 
 void TurnServer::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) {
     ProtocolType proto = server_listen_sockets_[server_socket];
     cricket::AsyncStunTCPSocket* tcp_socket =
@@ skipping 12 matching lines @@
 
 void TurnServer::OnInternalPacket(rtc::AsyncPacketSocket* socket,
                                   const char* data, size_t size,
                                   const rtc::SocketAddress& addr,
                                   const rtc::PacketTime& packet_time) {
   // Fail if the packet is too small to even contain a channel header.
   if (size < TURN_CHANNEL_HEADER_SIZE) {
    return;
   }
   InternalSocketMap::iterator iter = server_sockets_.find(socket);
-  ASSERT(iter != server_sockets_.end());
+  RTC_DCHECK(iter != server_sockets_.end());
   TurnServerConnection conn(addr, iter->second, socket);
   uint16_t msg_type = rtc::GetBE16(data);
   if (!IsTurnChannelData(msg_type)) {
     // This is a STUN message.
     HandleStunMessage(&conn, data, size);
   } else {
     // This is a channel message; let the allocation handle it.
     TurnServerAllocation* allocation = FindAllocation(&conn);
     if (allocation) {
       allocation->HandleChannelData(data, size);
@@ skipping 73 matching lines @@
 
   std::string username = username_attr->GetString();
   return (auth_hook_ != NULL && auth_hook_->GetKey(username, realm_, key));
 }
 
 bool TurnServer::CheckAuthorization(TurnServerConnection* conn,
                                     const StunMessage* msg,
                                     const char* data, size_t size,
                                     const std::string& key) {
   // RFC 5389, 10.2.2.
-  ASSERT(IsStunRequestType(msg->type()));
+  RTC_DCHECK(IsStunRequestType(msg->type()));
   const StunByteStringAttribute* mi_attr =
       msg->GetByteString(STUN_ATTR_MESSAGE_INTEGRITY);
   const StunByteStringAttribute* username_attr =
       msg->GetByteString(STUN_ATTR_USERNAME);
   const StunByteStringAttribute* realm_attr =
       msg->GetByteString(STUN_ATTR_REALM);
   const StunByteStringAttribute* nonce_attr =
       msg->GetByteString(STUN_ATTR_NONCE);
 
   // Fail if no M-I.
@@ skipping 84 matching lines @@
     SendErrorResponse(conn, msg, STUN_ERROR_SERVER_ERROR,
                       "Failed to allocate socket");
   }
 }
 
 std::string TurnServer::GenerateNonce(int64_t now) const {
   // Generate a nonce of the form hex(now + HMAC-MD5(nonce_key_, now))
   std::string input(reinterpret_cast<const char*>(&now), sizeof(now));
   std::string nonce = rtc::hex_encode(input.c_str(), input.size());
   nonce += rtc::ComputeHmac(rtc::DIGEST_MD5, nonce_key_, input);
-  ASSERT(nonce.size() == kNonceSize);
+  RTC_DCHECK(nonce.size() == kNonceSize);
 
   return nonce;
 }
 
 bool TurnServer::ValidateNonce(const std::string& nonce) const {
   // Check the size.
   if (nonce.size() != kNonceSize) {
     return false;
   }
 
@@ skipping 185 matching lines @@
   LOG_J(LS_INFO, this) << "Allocation destroyed";
 }
 
 std::string TurnServerAllocation::ToString() const {
   std::ostringstream ost;
   ost << "Alloc[" << conn_.ToString() << "]";
   return ost.str();
 }
 
 void TurnServerAllocation::HandleTurnMessage(const TurnMessage* msg) {
-  ASSERT(msg != NULL);
+  RTC_DCHECK(msg != NULL);
   switch (msg->type()) {
     case STUN_ALLOCATE_REQUEST:
       HandleAllocateRequest(msg);
       break;
     case TURN_REFRESH_REQUEST:
       HandleRefreshRequest(msg);
       break;
     case TURN_SEND_INDICATION:
       HandleSendIndication(msg);
       break;
     case TURN_CREATE_PERMISSION_REQUEST:
       HandleCreatePermissionRequest(msg);
       break;
     case TURN_CHANNEL_BIND_REQUEST:
       HandleChannelBindRequest(msg);
       break;
     default:
       // Not sure what to do with this, just eat it.
       LOG_J(LS_WARNING, this) << "Invalid TURN message type received: "
                               << msg->type();
   }
 }
 
 void TurnServerAllocation::HandleAllocateRequest(const TurnMessage* msg) {
   // Copy the important info from the allocate request.
   transaction_id_ = msg->transaction_id();
   const StunByteStringAttribute* username_attr =
       msg->GetByteString(STUN_ATTR_USERNAME);
-  ASSERT(username_attr != NULL);
+  RTC_DCHECK(username_attr != NULL);
   username_ = username_attr->GetString();
   const StunByteStringAttribute* origin_attr =
       msg->GetByteString(STUN_ATTR_ORIGIN);
   if (origin_attr) {
     origin_ = origin_attr->GetString();
   }
 
   // Figure out the lifetime and start the allocation timer.
   int lifetime_secs = ComputeLifetime(msg);
   thread_->PostDelayed(RTC_FROM_HERE, lifetime_secs * 1000, this,
@@ skipping 150 matching lines @@
     LOG_J(LS_WARNING, this) << "Received channel data for invalid channel, id="
                             << channel_id;
   }
 }
 
 void TurnServerAllocation::OnExternalPacket(
     rtc::AsyncPacketSocket* socket,
     const char* data, size_t size,
     const rtc::SocketAddress& addr,
     const rtc::PacketTime& packet_time) {
-  ASSERT(external_socket_.get() == socket);
+  RTC_DCHECK(external_socket_.get() == socket);
   Channel* channel = FindChannel(addr);
   if (channel) {
     // There is a channel bound to this address. Send as a channel message.
     rtc::ByteBufferWriter buf;
     buf.WriteUInt16(channel->id());
     buf.WriteUInt16(static_cast<uint16_t>(size));
     buf.WriteBytes(data, size);
     server_->Send(&conn_, buf);
   } else if (!server_->enable_permission_checks_ ||
              HasPermission(addr.ipaddr())) {
@@ skipping 84 matching lines @@
   server_->SendErrorResponse(&conn_, req, code, reason);
 }
 
 void TurnServerAllocation::SendExternal(const void* data, size_t size,
                                   const rtc::SocketAddress& peer) {
   rtc::PacketOptions options;
   external_socket_->SendTo(data, size, peer, options);
 }
 
 void TurnServerAllocation::OnMessage(rtc::Message* msg) {
-  ASSERT(msg->message_id == MSG_ALLOCATION_TIMEOUT);
+  RTC_DCHECK(msg->message_id == MSG_ALLOCATION_TIMEOUT);
   SignalDestroyed(this);
   delete this;
 }
 
 void TurnServerAllocation::OnPermissionDestroyed(Permission* perm) {
   PermissionList::iterator it = std::find(perms_.begin(), perms_.end(), perm);
-  ASSERT(it != perms_.end());
+  RTC_DCHECK(it != perms_.end());
   perms_.erase(it);
 }
 
 void TurnServerAllocation::OnChannelDestroyed(Channel* channel) {
   ChannelList::iterator it =
       std::find(channels_.begin(), channels_.end(), channel);
-  ASSERT(it != channels_.end());
+  RTC_DCHECK(it != channels_.end());
   channels_.erase(it);
 }
 
 TurnServerAllocation::Permission::Permission(rtc::Thread* thread,
                                    const rtc::IPAddress& peer)
     : thread_(thread), peer_(peer) {
   Refresh();
 }
 
 TurnServerAllocation::Permission::~Permission() {
   thread_->Clear(this, MSG_ALLOCATION_TIMEOUT);
 }
 
 void TurnServerAllocation::Permission::Refresh() {
   thread_->Clear(this, MSG_ALLOCATION_TIMEOUT);
   thread_->PostDelayed(RTC_FROM_HERE, kPermissionTimeout, this,
                        MSG_ALLOCATION_TIMEOUT);
 }
 
 void TurnServerAllocation::Permission::OnMessage(rtc::Message* msg) {
-  ASSERT(msg->message_id == MSG_ALLOCATION_TIMEOUT);
+  RTC_DCHECK(msg->message_id == MSG_ALLOCATION_TIMEOUT);
   SignalDestroyed(this);
   delete this;
 }
 
 TurnServerAllocation::Channel::Channel(rtc::Thread* thread, int id,
                              const rtc::SocketAddress& peer)
     : thread_(thread), id_(id), peer_(peer) {
   Refresh();
 }
 
 TurnServerAllocation::Channel::~Channel() {
   thread_->Clear(this, MSG_ALLOCATION_TIMEOUT);
 }
 
 void TurnServerAllocation::Channel::Refresh() {
   thread_->Clear(this, MSG_ALLOCATION_TIMEOUT);
   thread_->PostDelayed(RTC_FROM_HERE, kChannelTimeout, this,
                        MSG_ALLOCATION_TIMEOUT);
 }
 
 void TurnServerAllocation::Channel::OnMessage(rtc::Message* msg) {
-  ASSERT(msg->message_id == MSG_ALLOCATION_TIMEOUT);
+  RTC_DCHECK(msg->message_id == MSG_ALLOCATION_TIMEOUT);
   SignalDestroyed(this);
   delete this;
 }
 
 }  // namespace cricket